canvas 0.16.0__tar.gz → 0.17.0__tar.gz

canvas-0.17.0/.gitignore

@@ -0,0 +1,15 @@
+# MacOS artifacts
+.DS_Store
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+
+dist/
+
+# vim
+*.swp
+
+.env
+
+# JetBrains
+.idea/

{canvas-0.16.0 → canvas-0.17.0}/PKG-INFO

@@ -1,39 +1,34 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: canvas
-Version: 0.16.0
+Version: 0.17.0
 Summary: SDK to customize event-driven actions in your Canvas instance
-License: MIT
-Author: Canvas Team
-Author-email: engineering@canvasmedical.com
-Requires-Python: >=3.11,<3.13
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
+Author-email: Canvas Team <engineering@canvasmedical.com>
+License-Expression: MIT
+Requires-Python: <3.13,>=3.11
 Requires-Dist: cookiecutter
-Requires-Dist: cron-converter (>=1.2.1,<2.0.0)
-Requires-Dist: deprecation (>=2.1.0,<3.0.0)
-Requires-Dist: django (>=5.1.1,<6.0.0)
-Requires-Dist: django-stubs[compatible-mypy] (>=5.1.1,<6.0.0)
-Requires-Dist: django-timezone-utils (>=0.15.0,<0.16.0)
-Requires-Dist: env-tools (>=2.4.0,<3.0.0)
-Requires-Dist: grpcio (>=1.60.1,<2.0.0)
-Requires-Dist: ipython (>=8.21.0,<9.0.0)
-Requires-Dist: jsonschema (>=4.21.1,<5.0.0)
+Requires-Dist: cron-converter<2,>=1.2.1
+Requires-Dist: deprecation<3,>=2.1.0
+Requires-Dist: django-stubs[compatible-mypy]<6,>=5.1.1
+Requires-Dist: django-timezone-utils<0.16,>=0.15.0
+Requires-Dist: django<6,>=5.1.1
+Requires-Dist: env-tools<3,>=2.4.0
+Requires-Dist: grpcio<2,>=1.60.1
+Requires-Dist: ipython<9,>=8.21.0
+Requires-Dist: jsonschema<5,>=4.21.1
 Requires-Dist: keyring
-Requires-Dist: protobuf (>=4.25.3,<5.0.0)
-Requires-Dist: psycopg[binary] (>=3.2.2,<4.0.0)
-Requires-Dist: pydantic (>=2.6.1,<3.0.0)
-Requires-Dist: pyjwt (==2.10.1)
-Requires-Dist: python-dotenv (>=1.0.1,<2.0.0)
-Requires-Dist: rapidfuzz (>=3.10.1,<4.0.0)
-Requires-Dist: redis (>=5.0.4,<6.0.0)
+Requires-Dist: protobuf<5,>=4.25.3
+Requires-Dist: psycopg[binary]<4,>=3.2.2
+Requires-Dist: pydantic<3,>=2.6.1
+Requires-Dist: pyjwt==2.10.1
+Requires-Dist: python-dotenv<2,>=1.0.1
+Requires-Dist: rapidfuzz<4,>=3.10.1
+Requires-Dist: redis<6,>=5.0.4
 Requires-Dist: requests
-Requires-Dist: restrictedpython (>=7.1,<9.0)
-Requires-Dist: statsd (>=4.0.1,<5.0.0)
+Requires-Dist: restrictedpython>=8.0
+Requires-Dist: statsd<5,>=4.0.1
 Requires-Dist: typer
-Requires-Dist: typing-extensions (>=4.8,<4.13)
-Requires-Dist: websocket-client (>=1.7.0,<2.0.0)
+Requires-Dist: typing-extensions<4.13,>=4.8
+Requires-Dist: websocket-client<2,>=1.7.0
 Description-Content-Type: text/markdown
 
 ### Getting Started
@@ -220,4 +215,3 @@ $ canvas logs [OPTIONS]
 
 - `--host TEXT`: Canvas instance to connect to
 - `--help`: Show this message and exit.
-

{canvas-0.16.0 → canvas-0.17.0}/canvas_cli/apps/plugin/plugin.py

@@ -40,7 +40,7 @@ def validate_package(package: Path) -> Path:
 
 
 def _build_package(package: Path) -> Path:
-    """Runs `poetry build` on `package` and returns the built archive, ignoring symlinks, hidden folders, and hidden files."""
+    """Compresses `package` and returns the built archive, ignoring symlinks, hidden folders, and hidden files."""
     package = package.resolve()
 
     if not package.exists() or not package.is_dir():

{canvas-0.16.0 → canvas-0.17.0}/canvas_sdk/commands/tests/protocol/tests.py

@@ -1,8 +1,10 @@
 from collections.abc import Generator
 from datetime import datetime
+from typing import cast
 
 import pytest
 
+import settings
 from canvas_sdk.commands.tests.test_utils import (
     COMMANDS,
     MaskedValue,
@@ -12,6 +14,7 @@ from canvas_sdk.commands.tests.test_utils import (
     get_token,
     install_plugin,
     trigger_plugin_event,
+    wait_for_log,
     write_protocol_code,
 )
 
@@ -40,10 +43,18 @@ def write_and_install_protocol_and_clean_up(
 ) -> Generator[None, None, None]:
     """Write the protocol code, install the plugin, and clean up after the test."""
     write_protocol_code(new_note["externallyExposableId"], plugin_name, COMMANDS)
+    message_received_event, thread, ws = wait_for_log(
+        cast(str, settings.INTEGRATION_TEST_URL),
+        token.value,
+        f"Loading plugin '{plugin_name}",
+    )
     install_plugin(plugin_name, token)
+    message_received_event.wait(timeout=5.0)
 
     yield
 
+    ws.close()
+    thread.join()
     clean_up_files_and_plugins(plugin_name, token)
 
 
@@ -57,8 +68,7 @@ def test_protocol_that_inserts_every_command(
     commands_in_body = get_original_note_body_commands(new_note["id"], token)
 
     # TODO: Temporary workaround to ignore the updateGoal command until the integration test instance is fixed.
-    command_keys = [c.Meta.key for c in COMMANDS if c.Meta.key != "updateGoal"]
-
+    command_keys = [c.Meta.key for c in COMMANDS]
     assert len(command_keys) == len(commands_in_body)
     for i, command_key in enumerate(command_keys):
         assert commands_in_body[i] == command_key

{canvas-0.16.0 → canvas-0.17.0}/canvas_sdk/commands/tests/test_utils.py

@@ -190,11 +190,6 @@ class Protocol(BaseProtocol):
 def install_plugin(plugin_name: str, token: MaskedValue) -> None:
     """Install a plugin."""
     with open(_build_package(Path(f"./custom-plugins/{plugin_name}")), "rb") as package:
-        message_received_event = wait_for_log(
-            cast(str, settings.INTEGRATION_TEST_URL),
-            token.value,
-            f"Loading plugin '{plugin_name}",
-        )
         response = requests.post(
             plugin_url(cast(str, settings.INTEGRATION_TEST_URL)),
             data={"is_enabled": True},
@@ -203,8 +198,6 @@ def install_plugin(plugin_name: str, token: MaskedValue) -> None:
         )
         response.raise_for_status()
 
-        message_received_event.wait(timeout=5.0)
-
 
 def trigger_plugin_event(token: MaskedValue) -> None:
     """Trigger a plugin event."""
@@ -328,7 +321,9 @@ def get_token() -> MaskedValue:
     return MaskedValue(response.json()["access_token"])
 
 
-def wait_for_log(host: str, token: str, message: str) -> threading.Event:
+def wait_for_log(
+    host: str, token: str, message: str
+) -> tuple[threading.Event, threading.Thread, websocket.WebSocketApp]:
     """Wait for a specific log message."""
     hostname = cast(str, urlparse(host).hostname)
     instance = hostname.removesuffix(".canvasmedical.com")
@@ -362,4 +357,4 @@ def wait_for_log(host: str, token: str, message: str) -> threading.Event:
 
     connected_event.wait(timeout=5.0)
 
-    return message_received_event
+    return message_received_event, thread, ws

{canvas-0.16.0 → canvas-0.17.0}/canvas_sdk/effects/banner_alert/tests.py

@@ -92,10 +92,10 @@ class Protocol(BaseProtocol):
         protocol.write(protocol_code)
 
     with open(_build_package(Path(f"./custom-plugins/{plugin_name}")), "rb") as package:
-        message_received_event = wait_for_log(
+        message_received_event, thread, ws = wait_for_log(
             settings.INTEGRATION_TEST_URL,
             token.value,
-            f"Loading plugin '{plugin_name}:{plugin_name}.protocols.my_protocol:Protocol'",
+            f"Loading plugin '{plugin_name}",
         )
 
         # install the plugin
@@ -111,6 +111,9 @@ class Protocol(BaseProtocol):
 
     yield
 
+    ws.close()
+    thread.join()
+
     # clean up
     if Path(f"./custom-plugins/{plugin_name}").exists():
         shutil.rmtree(Path(f"./custom-plugins/{plugin_name}"))

{canvas-0.16.0 → canvas-0.17.0}/canvas_sdk/utils/http.py

@@ -26,7 +26,7 @@ class Http:
             result = fn(self, *args, **kwargs)
             end_time = time.time()
             timing = int((end_time - start_time) * 1000)
-            self.statsd_client.timing(f"http_{fn.__name__}", timing)
+            self.statsd_client.timing(f"plugins.http_{fn.__name__}", timing)
             return result
 
         return cast(F, wrapper)

{canvas-0.16.0 → canvas-0.17.0}/plugin_runner/plugin_installer.py

@@ -14,9 +14,17 @@ import requests
 from psycopg import Connection
 from psycopg.rows import dict_row
 
-import settings
 from plugin_runner.aws_headers import aws_sig_v4_headers
 from plugin_runner.exceptions import InvalidPluginFormat, PluginInstallationError
+from settings import (
+    AWS_ACCESS_KEY_ID,
+    AWS_REGION,
+    AWS_SECRET_ACCESS_KEY,
+    CUSTOMER_IDENTIFIER,
+    MEDIA_S3_BUCKET_NAME,
+    PLUGIN_DIRECTORY,
+    SECRETS_FILE_NAME,
+)
 
 # Plugin "packages" include this prefix in the database record for the plugin and the S3 bucket key.
 UPLOAD_TO_PREFIX = "plugins"
@@ -100,19 +108,19 @@ def _extract_rows_to_dict(rows: list) -> dict[str, PluginAttributes]:
 def download_plugin(plugin_package: str) -> Generator[Path, None, None]:
     """Download the plugin package from the S3 bucket."""
     method = "GET"
-    host = f"s3-{settings.AWS_REGION}.amazonaws.com"
-    bucket = settings.MEDIA_S3_BUCKET_NAME
-    customer_identifier = settings.CUSTOMER_IDENTIFIER
+    host = f"s3-{AWS_REGION}.amazonaws.com"
+    bucket = MEDIA_S3_BUCKET_NAME
+    customer_identifier = CUSTOMER_IDENTIFIER
     path = f"/{bucket}/{customer_identifier}/{plugin_package}"
     payload = b"This is required for the AWS headers because it is part of the signature"
     pre_auth_headers: dict[str, str] = {}
     query: dict[str, str] = {}
     headers = aws_sig_v4_headers(
-        settings.AWS_ACCESS_KEY_ID,
-        settings.AWS_SECRET_ACCESS_KEY,
+        AWS_ACCESS_KEY_ID,
+        AWS_SECRET_ACCESS_KEY,
         pre_auth_headers,
         "s3",
-        settings.AWS_REGION,
+        AWS_REGION,
         host,
         method,
         path,
@@ -135,7 +143,7 @@ def install_plugin(plugin_name: str, attributes: PluginAttributes) -> None:
     try:
         print(f"Installing plugin '{plugin_name}'")
 
-        plugin_installation_path = Path(settings.PLUGIN_DIRECTORY) / plugin_name
+        plugin_installation_path = Path(PLUGIN_DIRECTORY) / plugin_name
 
         # if plugin exists, first uninstall it
         if plugin_installation_path.exists():
@@ -175,7 +183,7 @@ 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}'")
 
-    secrets_path = Path(settings.PLUGIN_DIRECTORY) / plugin_name / settings.SECRETS_FILE_NAME
+    secrets_path = Path(PLUGIN_DIRECTORY) / plugin_name / SECRETS_FILE_NAME
 
     # Did the plugin ship a secrets.json? TOO BAD, IT'S GONE NOW.
     if Path(secrets_path).exists():
@@ -199,7 +207,7 @@ def disable_plugin(plugin_name: str) -> None:
 
 def uninstall_plugin(plugin_name: str) -> None:
     """Remove the plugin from the filesystem."""
-    plugin_path = Path(settings.PLUGIN_DIRECTORY) / plugin_name
+    plugin_path = Path(PLUGIN_DIRECTORY) / plugin_name
 
     if plugin_path.exists():
         shutil.rmtree(plugin_path)
@@ -207,10 +215,10 @@ def uninstall_plugin(plugin_name: str) -> None:
 
 def install_plugins() -> None:
     """Install all enabled plugins."""
-    if Path(settings.PLUGIN_DIRECTORY).exists():
-        shutil.rmtree(settings.PLUGIN_DIRECTORY)
+    if Path(PLUGIN_DIRECTORY).exists():
+        shutil.rmtree(PLUGIN_DIRECTORY)
 
-    os.mkdir(settings.PLUGIN_DIRECTORY)
+    os.mkdir(PLUGIN_DIRECTORY)
 
     for plugin_name, attributes in enabled_plugins().items():
         try:

{canvas-0.16.0 → canvas-0.17.0}/plugin_runner/plugin_runner.py

@@ -2,17 +2,17 @@ import asyncio
 import json
 import os
 import pathlib
+import pickle
 import pkgutil
-import signal
 import sys
 import time
 import traceback
 from collections import defaultdict
 from collections.abc import AsyncGenerator
-from types import FrameType
 from typing import Any, TypedDict
 
 import grpc
+import redis.asyncio as redis
 import statsd
 
 from canvas_generated.messages.effects_pb2 import EffectType
@@ -30,9 +30,15 @@ from canvas_sdk.protocols import ClinicalQualityMeasure
 from canvas_sdk.utils.stats import get_duration_ms, tags_to_line_protocol
 from logger import log
 from plugin_runner.authentication import token_for_plugin
-from plugin_runner.plugin_synchronizer import publish_message
+from plugin_runner.plugin_installer import install_plugins
 from plugin_runner.sandbox import Sandbox
-from settings import MANIFEST_FILE_NAME, PLUGIN_DIRECTORY, SECRETS_FILE_NAME
+from settings import (
+    CHANNEL_NAME,
+    MANIFEST_FILE_NAME,
+    PLUGIN_DIRECTORY,
+    REDIS_ENDPOINT,
+    SECRETS_FILE_NAME,
+)
 
 # when we import plugins we'll use the module name directly so we need to add the plugin
 # directory to the path
@@ -192,14 +198,50 @@ class PluginRunner(PluginRunnerServicer):
         self, request: ReloadPluginsRequest, context: Any
     ) -> AsyncGenerator[ReloadPluginsResponse, None]:
         """This is invoked when we need to reload plugins."""
+        log.info("Reloading plugins...")
         try:
-            publish_message({"action": "restart"})
+            await publish_message(message={"action": "reload"})
         except ImportError:
             yield ReloadPluginsResponse(success=False)
         else:
             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."""
+    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
+        message = await pubsub.get_message(ignore_subscribe_messages=True, timeout=None)
+        if message is not None:
+            log.info("Received message from pubsub channel")
+
+            message_type = message.get("type", "")
+
+            if message_type != "pmessage":
+                continue
+
+            data = pickle.loads(message.get("data", pickle.dumps({})))
+
+            if "action" not in data:
+                continue
+
+            if data["action"] == "reload":
+                try:
+                    log.info(
+                        "plugin-synchronizer: installing and reloading plugins after receiving command"
+                    )
+                    install_plugins()
+                    load_plugins()
+                except Exception as e:
+                    print("plugin-synchronizer: `install_plugins` failed:", e)
+
+
 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.
@@ -237,12 +279,6 @@ def apply_effects_to_context(effects: list[Effect], event: Event) -> Event:
     return event
 
 
-def handle_hup_cb(_signum: int, _frame: FrameType | None) -> None:
-    """handle_hup_cb."""
-    log.info("Received SIGHUP, reloading plugins...")
-    load_plugins()
-
-
 def find_modules(base_path: pathlib.Path, prefix: str | None = None) -> list[str]:
     """Find all modules in the specified package path."""
     modules: list[str] = []
@@ -273,6 +309,22 @@ def sandbox_from_module(base_path: pathlib.Path, module_name: str) -> Any:
     return sandbox.execute()
 
 
+async def publish_message(message: dict) -> None:
+    """Publish a message to the pubsub channel."""
+    log.info("Publishing message to pubsub channel")
+    client, _ = get_client()
+
+    await client.publish(CHANNEL_NAME, pickle.dumps(message))
+
+
+def get_client() -> tuple[redis.Redis, redis.client.PubSub]:
+    """Return an async Redis client and pubsub object."""
+    client = redis.Redis.from_url(REDIS_ENDPOINT)
+    pubsub = client.pubsub()
+
+    return client, pubsub
+
+
 def load_or_reload_plugin(path: pathlib.Path) -> None:
     """Given a path, load or reload a plugin."""
     log.info(f"Loading {path}")
@@ -415,6 +467,7 @@ async def serve(specified_plugin_paths: list[str] | None = None) -> None:
 
     log.info(f"Starting server, listening on port {port}")
 
+    install_plugins()
     load_plugins(specified_plugin_paths)
 
     await server.start()
@@ -434,10 +487,10 @@ def run_server(specified_plugin_paths: list[str] | None = None) -> None:
 
     asyncio.set_event_loop(loop)
 
-    signal.signal(signal.SIGHUP, handle_hup_cb)
-
     try:
-        loop.run_until_complete(serve(specified_plugin_paths))
+        loop.run_until_complete(
+            asyncio.gather(serve(specified_plugin_paths), synchronize_plugins())
+        )
     except KeyboardInterrupt:
         pass
     finally:

{canvas-0.16.0 → canvas-0.17.0}/plugin_runner/tests/test_plugin_runner.py

@@ -1,7 +1,9 @@
+import asyncio
 import logging
+import pickle
 import shutil
 from pathlib import Path
-from unittest.mock import MagicMock, patch
+from unittest.mock import AsyncMock, MagicMock, patch
 
 import pytest
 
@@ -14,6 +16,7 @@ from plugin_runner.plugin_runner import (
     PluginRunner,
     load_or_reload_plugin,
     load_plugins,
+    synchronize_plugins,
 )
 
 
@@ -229,24 +232,53 @@ async def test_handle_plugin_event_returns_expected_result(
 
 
 @pytest.mark.asyncio
-@pytest.mark.parametrize("install_test_plugin", ["example_plugin"], indirect=True)
 async def test_reload_plugins_event_handler_successfully_publishes_message(
-    install_test_plugin: Path, plugin_runner: PluginRunner
+    plugin_runner: PluginRunner,
 ) -> None:
     """Test ReloadPlugins Event handler successfully publishes a message with restart action."""
-    with patch("plugin_runner.plugin_runner.publish_message", MagicMock()) as mock_publish_message:
+    with patch(
+        "plugin_runner.plugin_runner.publish_message", new_callable=AsyncMock
+    ) as mock_publish_message:
         request = ReloadPluginsRequest()
 
         result = []
         async for response in plugin_runner.ReloadPlugins(request, None):
             result.append(response)
 
-        mock_publish_message.assert_called_once_with({"action": "restart"})
+        mock_publish_message.assert_called_once_with(message={"action": "reload"})
 
     assert len(result) == 1
     assert result[0].success is True
 
 
+@pytest.mark.asyncio
+async def test_synchronize_plugins_calls_install_and_load_plugins() -> None:
+    """Test that synchronize_plugins calls install_plugins and load_plugins."""
+    with (
+        patch("plugin_runner.plugin_runner.get_client", new_callable=MagicMock) as mock_get_client,
+        patch(
+            "plugin_runner.plugin_runner.install_plugins", new_callable=AsyncMock
+        ) as mock_install_plugins,
+        patch(
+            "plugin_runner.plugin_runner.load_plugins", new_callable=AsyncMock
+        ) as mock_load_plugins,
+    ):
+        mock_client = AsyncMock()
+        mock_pubsub = AsyncMock()
+        mock_get_client.return_value = (mock_client, mock_pubsub)
+        mock_pubsub.get_message.return_value = {
+            "type": "pmessage",
+            "data": pickle.dumps({"action": "reload"}),
+        }
+
+        task = asyncio.create_task(synchronize_plugins(max_iterations=1))
+        await asyncio.sleep(0.1)  # Give some time for the coroutine to run
+        task.cancel()
+
+        mock_install_plugins.assert_called_once()
+        mock_load_plugins.assert_called_once()
+
+
 @pytest.mark.asyncio
 @pytest.mark.parametrize("install_test_plugin", ["test_module_imports_plugin"], indirect=True)
 async def test_changes_to_plugin_modules_should_be_reflected_after_reload(