canvas 0.53.1__py3-none-any.whl → 0.54.0__py3-none-any.whl

canvas_sdk/utils/plugins.py

@@ -8,19 +8,39 @@ from canvas_sdk.utils.metrics import measured
 from settings import PLUGIN_DIRECTORY
 
 
+def find_plugin_ancestor(frame: FrameType | None, max_depth: int = 10) -> FrameType | None:
+    """
+    Recurse backwards to find any plugin ancestor of this frame.
+    """
+    parent_frame = frame.f_back if frame else None
+
+    if not parent_frame:
+        return None
+
+    if max_depth == 0:
+        return None
+
+    if "__is_plugin__" in parent_frame.f_globals:
+        return parent_frame
+
+    return find_plugin_ancestor(frame=parent_frame, max_depth=max_depth - 1)
+
+
 @measured
-def plugin_only(func: Callable[..., Any]) -> Callable[..., Any]:
+def plugin_context(func: Callable[..., Any]) -> Callable[..., Any]:
     """Decorator to restrict a function's execution to plugins only."""
 
     def wrapper(*args: Any, **kwargs: Any) -> Any:
-        current_frame = inspect.currentframe()
-        caller = current_frame.f_back if current_frame else None
+        plugin_frame = find_plugin_ancestor(inspect.currentframe())
 
-        if not caller or "__is_plugin__" not in caller.f_globals:
-            return None
+        if not plugin_frame:
+            raise RuntimeError(
+                "Method that expected plugin context was called from outside a plugin."
+            )
 
-        plugin_name = caller.f_globals["__name__"].split(".")[0]
+        plugin_name = plugin_frame.f_globals["__name__"].split(".")[0]
         plugin_dir = Path(PLUGIN_DIRECTORY) / plugin_name
+
         kwargs["plugin_name"] = plugin_name
         kwargs["plugin_dir"] = plugin_dir.resolve()
 
@@ -30,24 +50,17 @@ def plugin_only(func: Callable[..., Any]) -> Callable[..., Any]:
 
 
 @measured
-def is_plugin_caller(depth: int = 10, frame: FrameType | None = None) -> tuple[bool, str | None]:
+def is_plugin_caller() -> tuple[bool, str | None]:
     """Check if a function is called from a plugin."""
-    current_frame = frame or inspect.currentframe()
-    caller = current_frame.f_back if current_frame else None
-
-    if not caller:
-        return False, None
+    plugin_frame = find_plugin_ancestor(inspect.currentframe())
 
-    if "__is_plugin__" not in caller.f_globals:
-        if depth > 0:
-            return is_plugin_caller(frame=caller, depth=depth - 1)
-        else:
-            return False, None
+    if plugin_frame:
+        module = plugin_frame.f_globals.get("__name__")
+        qualname = plugin_frame.f_code.co_qualname
 
-    module = caller.f_globals.get("__name__")
-    qualname = caller.f_code.co_qualname
+        return True, f"{module}.{qualname}"
 
-    return True, f"{module}.{qualname}"
+    return False, None
 
 
 __exports__ = ()

canvas_sdk/v1/data/patient.py

@@ -99,6 +99,13 @@ class Patient(Model):
     def __str__(self) -> str:
         return f"{self.first_name} {self.last_name}"
 
+    @property
+    def full_name(self) -> str:
+        """Returns the patient's full name."""
+        return " ".join(
+            n for n in (self.first_name, self.middle_name, self.last_name, self.suffix) if n
+        )
+
     def age_at(self, time: arrow.Arrow) -> float:
         """Given a datetime, returns what the patient's age would be at that datetime."""
         age = float(0)

plugin_runner/allowed-module-imports.json

@@ -279,6 +279,14 @@
   "canvas_sdk.effects.patient_profile_configuration": [
     "PatientProfileConfiguration"
   ],
+  "canvas_sdk.effects.payment_processor": [
+    "AddPaymentMethodResponse",
+    "CardTransaction",
+    "PaymentMethod",
+    "PaymentProcessorForm",
+    "PaymentProcessorMetadata",
+    "RemovePaymentMethodResponse"
+  ],
   "canvas_sdk.effects.protocol_card": [
     "ProtocolCard",
     "Recommendation"
@@ -364,6 +372,12 @@
   "canvas_sdk.handlers.cron_task": [
     "CronTask"
   ],
+  "canvas_sdk.handlers.payment_processors.base": [
+    "PaymentProcessor"
+  ],
+  "canvas_sdk.handlers.payment_processors.card": [
+    "CardPaymentProcessor"
+  ],
   "canvas_sdk.handlers.simple_api": [
     "APIKeyAuthMixin",
     "APIKeyCredentials",

plugin_runner/exceptions.py

@@ -12,3 +12,7 @@ class InvalidPluginFormat(PluginValidationError):
 
 class PluginInstallationError(PluginError):
     """An exception raised when a plugin fails to install."""
+
+
+class PluginUninstallationError(PluginError):
+    """An exception raised when a plugin fails to uninstall."""

plugin_runner/installation.py

@@ -17,7 +17,11 @@ 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 plugin_runner.exceptions import (
+    InvalidPluginFormat,
+    PluginInstallationError,
+    PluginUninstallationError,
+)
 from settings import (
     AWS_ACCESS_KEY_ID,
     AWS_REGION,
@@ -68,15 +72,28 @@ class PluginAttributes(TypedDict):
     secrets: dict[str, str]
 
 
-def enabled_plugins() -> dict[str, PluginAttributes]:
-    """Returns a dictionary of enabled plugins and their attributes."""
+def enabled_plugins(plugin_names: list[str] | None = None) -> dict[str, PluginAttributes]:
+    """Returns a dictionary of enabled plugins and their attributes.
+
+    If `plugin_names` is provided, only returns those plugins (if enabled).
+    """
     conn = open_database_connection()
 
     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"
+        base_query = (
+            "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"
         )
+
+        params = []
+        if plugin_names:
+            placeholders = ",".join(["%s"] * len(plugin_names))
+            base_query += f" AND name IN ({placeholders})"
+            params.extend(plugin_names)
+
+        cursor.execute(base_query, params)
         rows = cursor.fetchall()
         plugins = _extract_rows_to_dict(rows)
 
@@ -130,6 +147,8 @@ def download_plugin(plugin_package: str) -> Generator[Path, None, None]:
 
         with open(download_path, "wb") as download_file:
             response = requests.request(method=method, url=f"https://{host}{path}", headers=headers)
+            response.raise_for_status()
+
             download_file.write(response.content)
 
         yield download_path
@@ -151,7 +170,8 @@ def install_plugin(plugin_name: str, attributes: PluginAttributes) -> None:
 
         install_plugin_secrets(plugin_name=plugin_name, secrets=attributes["secrets"])
     except Exception as e:
-        log.error(f'Failed to install plugin "{plugin_name}", version {attributes["version"]}')
+        log.error(f'Failed to install plugin "{plugin_name}", version {attributes["version"]}: {e}')
+
         sentry_sdk.capture_exception(e)
 
         raise PluginInstallationError() from e
@@ -210,22 +230,31 @@ 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}"')
+    try:
+        log.info(f'Uninstalling plugin "{plugin_name}"')
 
-    plugin_path = Path(PLUGIN_DIRECTORY) / plugin_name
+        plugin_path = Path(PLUGIN_DIRECTORY) / plugin_name
 
-    if plugin_path.exists():
-        shutil.rmtree(plugin_path)
+        if plugin_path.exists():
+            shutil.rmtree(plugin_path)
+    except Exception as e:
+        raise PluginUninstallationError() from e
 
 
 def install_plugins() -> None:
     """Install all enabled plugins."""
     log.info("Installing plugins")
+    try:
+        plugins_dir = Path(PLUGIN_DIRECTORY).resolve()
 
-    if Path(PLUGIN_DIRECTORY).exists():
-        shutil.rmtree(PLUGIN_DIRECTORY)
+        if plugins_dir.exists():
+            shutil.rmtree(plugins_dir.as_posix())
 
-    os.mkdir(PLUGIN_DIRECTORY)
+        plugins_dir.mkdir(parents=False, exist_ok=True)
+    except Exception as e:
+        raise PluginInstallationError(
+            f'Failed to reset plugin directory "{PLUGIN_DIRECTORY}": {e}"'
+        ) from e
 
     for plugin_name, attributes in enabled_plugins().items():
         try:

plugin_runner/plugin_runner.py

@@ -1,3 +1,4 @@
+import base64
 import json
 import os
 import pathlib
@@ -24,7 +25,14 @@ from sentry_sdk.integrations.logging import ignore_logger
 
 import settings
 from canvas_generated.messages.effects_pb2 import EffectType
-from canvas_generated.messages.plugins_pb2 import ReloadPluginsRequest, ReloadPluginsResponse
+from canvas_generated.messages.plugins_pb2 import (
+    ReloadPluginRequest,
+    ReloadPluginResponse,
+    ReloadPluginsRequest,
+    ReloadPluginsResponse,
+    UnloadPluginRequest,
+    UnloadPluginResponse,
+)
 from canvas_generated.services.plugin_runner_pb2_grpc import (
     PluginRunnerServicer,
     add_PluginRunnerServicer_to_server,
@@ -38,7 +46,13 @@ from canvas_sdk.utils import metrics
 from canvas_sdk.utils.metrics import measured
 from logger import log
 from plugin_runner.authentication import token_for_plugin
-from plugin_runner.installation import install_plugins
+from plugin_runner.exceptions import PluginInstallationError, PluginUninstallationError
+from plugin_runner.installation import (
+    enabled_plugins,
+    install_plugin,
+    install_plugins,
+    uninstall_plugin,
+)
 from plugin_runner.sandbox import Sandbox, sandbox_from_module
 from settings import (
     CHANNEL_NAME,
@@ -200,6 +214,28 @@ class PluginRunner(PluginRunnerServicer):
                 # respond to SimpleAPI request events are not relevant
                 plugin_name = event.context["plugin_name"]
                 relevant_plugins = [p for p in relevant_plugins if p.startswith(f"{plugin_name}:")]
+            elif event_type in {
+                EventType.REVENUE__PAYMENT_PROCESSOR__CHARGE,
+                EventType.REVENUE__PAYMENT_PROCESSOR__SELECTED,
+                EventType.REVENUE__PAYMENT_PROCESSOR__PAYMENT_METHODS__LIST,
+                EventType.REVENUE__PAYMENT_PROCESSOR__PAYMENT_METHODS__ADD,
+                EventType.REVENUE__PAYMENT_PROCESSOR__PAYMENT_METHODS__REMOVE,
+            }:
+                # The target plugin's name will be part of the payment processor identifier, so other plugins that
+                # respond to payment processor charge events are not relevant
+                try:
+                    plugin_name = (
+                        base64.b64decode(event.context["identifier"]).decode("utf-8").split(".")[0]
+                    )
+                    relevant_plugins = [
+                        p for p in relevant_plugins if p.startswith(f"{plugin_name}:")
+                    ]
+                except Exception as ex:
+                    log.error(
+                        f"Failed to decode identifier for event {event_name} with context {event.context}"
+                    )
+                    sentry_sdk.capture_exception(ex)
+                    relevant_plugins = []
 
             effect_list = []
 
@@ -305,14 +341,51 @@ class PluginRunner(PluginRunnerServicer):
         self, request: ReloadPluginsRequest, context: Any
     ) -> Iterable[ReloadPluginsResponse]:
         """This is invoked when we need to reload plugins."""
-        log.info("Reloading plugins...")
+        log.info("Reloading all plugins...")
+
+        message = {"action": "reload"}
+
         try:
-            publish_message(message={"action": "reload"})
+            publish_message(message=message)
         except ImportError:
             yield ReloadPluginsResponse(success=False)
         else:
             yield ReloadPluginsResponse(success=True)
 
+    def ReloadPlugin(
+        self, request: ReloadPluginRequest, context: Any
+    ) -> Iterable[ReloadPluginResponse]:
+        """This is invoked when we need to reload a specific plugin."""
+        log.info(f'Reloading plugin "{request.plugin}"...')
+
+        message = {
+            "action": "reload",
+            "plugin": request.plugin,
+        }
+        try:
+            publish_message(message=message)
+        except ImportError:
+            yield ReloadPluginResponse(success=False)
+        else:
+            yield ReloadPluginResponse(success=True)
+
+    def UnloadPlugin(
+        self, request: UnloadPluginRequest, context: Any
+    ) -> Iterable[UnloadPluginResponse]:
+        """This is invoked when we need to reload a specific plugin."""
+        log.info(f'Unloading plugin "{request.plugin}"...')
+
+        message = {
+            "action": "unload",
+            "plugin": request.plugin,
+        }
+        try:
+            publish_message(message=message)
+        except ImportError:
+            yield UnloadPluginResponse(success=False)
+        else:
+            yield UnloadPluginResponse(success=True)
+
 
 STOP_SYNCHRONIZER = threading.Event()
 
@@ -346,20 +419,40 @@ def synchronize_plugins(run_once: bool = False) -> None:
         if "action" not in data:
             continue
 
-        if data["action"] == "reload":
-            log.info("synchronize_plugins: installing/reloading plugins for action=reload")
+        plugin_name = data.get("plugin", None)
+        try:
+            if data["action"] == "reload":
+                if plugin_name:
+                    plugin = enabled_plugins([plugin_name]).get(plugin_name, None)
+
+                    if plugin:
+                        log.info(
+                            f'synchronize_plugins: installing/reloading plugin "{plugin_name}" for action=reload'
+                        )
+                        install_plugin(plugin_name, attributes=plugin)
+                        plugin_dir = pathlib.Path(PLUGIN_DIRECTORY) / plugin_name
+                        load_plugin(plugin_dir.resolve())
+                else:
+                    log.info("synchronize_plugins: installing/reloading plugins for action=reload")
+                    install_plugins()
+                    load_plugins()
+            elif data["action"] == "unload" and plugin_name:
+                log.info(f'synchronize_plugins: uninstalling plugin "{plugin_name}"')
+                unload_plugin(plugin_name)
+                uninstall_plugin(plugin_name)
+        except Exception as e:
+            if isinstance(e, PluginInstallationError):
+                message = "install_plugins failed"
+            elif isinstance(e, PluginUninstallationError):
+                message = "uninstall_plugin failed"
+            else:
+                message = "load_plugins failed"
 
-            try:
-                install_plugins()
-            except Exception as e:
-                log.error(f"synchronize_plugins: install_plugins failed: {e}")
-                sentry_sdk.capture_exception(e)
+            if plugin_name:
+                message += f' for plugin "{plugin_name}"'
 
-            try:
-                load_plugins()
-            except Exception as e:
-                log.error(f"synchronize_plugins: load_plugins failed: {e}")
-                sentry_sdk.capture_exception(e)
+            log.error(f"synchronize_plugins: {message}: {e}")
+            sentry_sdk.capture_exception(e)
 
         if run_once:
             break
@@ -523,7 +616,7 @@ def load_or_reload_plugin(path: pathlib.Path) -> bool:
             result = sandbox.execute()
 
             if name_and_class in LOADED_PLUGINS:
-                log.info(f"Reloading plugin '{name_and_class}'")
+                log.info(f"Reloading handler '{name_and_class}'")
 
                 LOADED_PLUGINS[name_and_class]["active"] = True
 
@@ -531,7 +624,7 @@ def load_or_reload_plugin(path: pathlib.Path) -> bool:
                 LOADED_PLUGINS[name_and_class]["sandbox"] = result
                 LOADED_PLUGINS[name_and_class]["secrets"] = secrets_json
             else:
-                log.info(f"Loading plugin '{name_and_class}'")
+                log.info(f'Loading handler "{name_and_class}"')
 
                 LOADED_PLUGINS[name_and_class] = {
                     "active": True,
@@ -553,6 +646,23 @@ def load_or_reload_plugin(path: pathlib.Path) -> bool:
     return not any_failed
 
 
+def unload_plugin(name: str) -> None:
+    """Unload a plugin by its name."""
+    handlers_removed = False
+
+    for handler_name in LOADED_PLUGINS.copy():
+        if handler_name.startswith(f"{name}:"):
+            log.info(f'Unloading handler "{handler_name}"')
+            del LOADED_PLUGINS[handler_name]
+            handlers_removed = True
+
+    if handlers_removed:
+        # Refresh the event type map to remove any handlers for the unloaded plugin
+        refresh_event_type_map()
+    else:
+        log.warning(f"No handlers found for plugin '{name}' to unload.")
+
+
 def refresh_event_type_map() -> None:
     """Ensure the event subscriptions are up to date."""
     EVENT_HANDLER_MAP.clear()
@@ -608,6 +718,13 @@ def load_plugins(specified_plugin_paths: list[str] | None = None) -> None:
     refresh_event_type_map()
 
 
+@measured
+def load_plugin(path: pathlib.Path) -> None:
+    """Load a plugin from the specified path."""
+    load_or_reload_plugin(path)
+    refresh_event_type_map()
+
+
 # NOTE: specified_plugin_paths powers the `canvas run-plugins` command
 def main(specified_plugin_paths: list[str] | None = None) -> None:
     """Run the server and the synchronize_plugins loop."""

plugin_runner/sandbox.py

@@ -225,6 +225,7 @@ THIRD_PARTY_MODULES = {
     },
     "pydantic": {
         "BaseModel",
+        "ConfigDict",
         "conint",
         "constr",
         "Field",

protobufs/canvas_generated/messages/effects.proto

@@ -303,6 +303,14 @@ enum EffectType {
 
   CREATE_COMPOUND_MEDICATION = 6020;
   UPDATE_COMPOUND_MEDICATION = 6021;
+
+  REVENUE__PAYMENT_PROCESSOR__METADATA = 7001;
+  REVENUE__PAYMENT_PROCESSOR__FORM = 7002;
+  REVENUE__PAYMENT_PROCESSOR__CREDIT_CARD_TRANSACTION = 7003;
+  REVENUE__PAYMENT_PROCESSOR__PAYMENT_METHOD = 7004;
+  REVENUE__PAYMENT_PROCESSOR__PAYMENT_METHOD__ADD_RESPONSE = 7005;
+  REVENUE__PAYMENT_PROCESSOR__PAYMENT_METHOD__REMOVE_RESPONSE = 7006;
+
 }
 
 message Effect {

protobufs/canvas_generated/messages/events.proto

@@ -1160,6 +1160,14 @@ enum EventType {
   DOCUMENT_REFERENCE_CREATED = 150000;
   DOCUMENT_REFERENCE_UPDATED = 150001;
   DOCUMENT_REFERENCE_DELETED = 150002;
+
+
+  REVENUE__PAYMENT_PROCESSOR__LIST = 160001;
+  REVENUE__PAYMENT_PROCESSOR__CHARGE = 160003;
+  REVENUE__PAYMENT_PROCESSOR__SELECTED = 160002;
+  REVENUE__PAYMENT_PROCESSOR__PAYMENT_METHODS__LIST = 160004;
+  REVENUE__PAYMENT_PROCESSOR__PAYMENT_METHODS__ADD = 160005;
+  REVENUE__PAYMENT_PROCESSOR__PAYMENT_METHODS__REMOVE = 160006;
 }
 
 message Event {

protobufs/canvas_generated/messages/plugins.proto

@@ -1,9 +1,24 @@
 syntax = "proto3";
 
 message ReloadPluginsRequest {
-
 }
 
 message ReloadPluginsResponse {
   bool success = 1;
 }
+
+message ReloadPluginRequest {
+  string plugin = 1;
+}
+
+message ReloadPluginResponse {
+  bool success = 1;
+}
+
+message UnloadPluginRequest {
+  string plugin = 1;
+}
+
+message UnloadPluginResponse {
+  bool success = 1;
+}

protobufs/canvas_generated/services/plugin_runner.proto

@@ -9,4 +9,8 @@ service PluginRunner {
   rpc HandleEvent (Event) returns (stream EventResponse);
 
   rpc ReloadPlugins (ReloadPluginsRequest) returns (stream ReloadPluginsResponse);
+
+  rpc ReloadPlugin (ReloadPluginRequest) returns (stream ReloadPluginResponse);
+
+  rpc UnloadPlugin (UnloadPluginRequest) returns (stream UnloadPluginResponse);
 }