canvas 0.45.0__py3-none-any.whl → 0.47.0__py3-none-any.whl

plugin_runner/generate_allowed_imports.py

@@ -0,0 +1,97 @@
+import importlib
+import json
+import pkgutil
+from collections.abc import Iterable
+from pathlib import Path
+from typing import Any
+
+CANVAS_TOP_LEVEL_MODULES = (
+    "canvas_sdk.caching",
+    "canvas_sdk.commands",
+    "canvas_sdk.effects",
+    "canvas_sdk.events",
+    "canvas_sdk.handlers",
+    "canvas_sdk.protocols",
+    "canvas_sdk.questionnaires",
+    "canvas_sdk.templates",
+    "canvas_sdk.utils",
+    "canvas_sdk.v1",
+    "canvas_sdk.value_set",
+    "canvas_sdk.views",
+    "logger",
+)
+
+
+def find_submodules(starting_modules: Iterable[str]) -> list[str]:
+    """
+    Given a list of modules, return a list of those modules and their submodules.
+    """
+    submodules = set(starting_modules)
+
+    for module_path in starting_modules:
+        try:
+            module = importlib.import_module(module_path)
+
+            if not hasattr(module, "__path__"):
+                continue
+
+            for _, name, _ in pkgutil.walk_packages(module.__path__, prefix=module.__name__ + "."):
+                submodules.add(name)
+
+        except Exception as e:
+            print(f"could not import {module_path}: {e}")
+
+    return sorted(submodules)
+
+
+def main() -> None:
+    """
+    Generate a JSON file of the allowed canvas_sdk imports.
+    """
+    print("Generating allowed canavs_sdk imports...")
+
+    CANVAS_SUBMODULE_NAMES = [
+        found_module
+        for found_module in find_submodules(CANVAS_TOP_LEVEL_MODULES)
+        # tests are excluded from the built and distributed module in pyproject.toml
+        if "tests" not in found_module and "test_" not in found_module
+    ]
+
+    CANVAS_MODULES: dict[str, set[str]] = {}
+
+    for module_name in CANVAS_SUBMODULE_NAMES:
+        module = importlib.import_module(module_name)
+
+        exports = getattr(module, "__exports__", None)
+
+        if not exports:
+            continue
+
+        if module_name not in CANVAS_MODULES:
+            CANVAS_MODULES[module_name] = set()
+
+        CANVAS_MODULES[module_name].update(exports)
+
+    # In use by a current plugin...
+    CANVAS_MODULES["canvas_sdk.commands"].add("*")
+
+    def default(o: Any) -> Any:
+        if isinstance(o, set):
+            return sorted(o)
+
+        raise TypeError(f"Object of type {type(o).__name__} is not JSON serializable")
+
+    allowed_module_imports_path = Path(__file__).parent / "allowed-module-imports.json"
+
+    allowed_module_imports_path.write_text(
+        json.dumps(
+            CANVAS_MODULES,
+            default=default,
+            indent=2,
+            sort_keys=True,
+        )
+    )
+
+
+if __name__ == "__main__":
+    main()

plugin_runner/plugin_runner.py

@@ -53,11 +53,20 @@ from settings import (
 )
 
 if SENTRY_DSN:
+    # Lazy import for faster reload time in dev
+    from sentry_sdk.integrations.executing import ExecutingIntegration
+    from sentry_sdk.integrations.pure_eval import PureEvalIntegration
+
     sentry_sdk.init(
         dsn=SENTRY_DSN,
         environment=ENV,
+        integrations=[
+            ExecutingIntegration(),
+            PureEvalIntegration(),
+        ],
         release=os.getenv("CANVAS_PLUGINS_REPO_VERSION", "unknown"),
         send_default_pii=True,
+        spotlight=False,
         traces_sample_rate=0.0,
         profiles_sample_rate=0.0,
     )

plugin_runner/sandbox.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import ast
 import builtins
 import importlib
-import pkgutil
+import json
 import sys
 import types
 from _ast import AnnAssign
@@ -43,25 +43,17 @@ if TYPE_CHECKING:
         names_to_module: dict[str, str]
 
 
-def find_submodules(starting_modules: Iterable[str]) -> list[str]:
-    """
-    Given a list of modules, return a list of those modules and their submodules.
-    """
-    submodules = set(starting_modules)
-
-    for module_path in starting_modules:
-        try:
-            module = importlib.import_module(module_path)
+try:
+    allowed_module_imports_path = Path(__file__).parent / "allowed-module-imports.json"
 
-            if not hasattr(module, "__path__"):
-                continue
+    CANVAS_MODULES: dict[str, Iterable[str]] = json.loads(allowed_module_imports_path.read_text())
 
-            for _, name, _ in pkgutil.walk_packages(module.__path__, prefix=module.__name__ + "."):
-                submodules.add(name)
-        except Exception as e:
-            print(f"could not import {module_path}: {e}")
+    for key in CANVAS_MODULES:
+        CANVAS_MODULES[key] = set(CANVAS_MODULES[key])
 
-    return sorted(submodules)
+except FileNotFoundError:
+    print("Error: Unable to load plugin_runner/allowed-module-imports.json, aborting")
+    sys.exit(1)
 
 
 SAFE_INTERNAL_DUNDER_READ_ATTRIBUTES = {
@@ -80,48 +72,6 @@ SAFE_EXTERNAL_DUNDER_READ_ATTRIBUTES = {
     "__name__",
 }
 
-CANVAS_TOP_LEVEL_MODULES = (
-    "canvas_sdk.caching",
-    "canvas_sdk.commands",
-    "canvas_sdk.effects",
-    "canvas_sdk.events",
-    "canvas_sdk.handlers",
-    "canvas_sdk.protocols",
-    "canvas_sdk.questionnaires",
-    "canvas_sdk.templates",
-    "canvas_sdk.utils",
-    "canvas_sdk.v1",
-    "canvas_sdk.value_set",
-    "canvas_sdk.views",
-    "logger",
-)
-
-CANVAS_SUBMODULE_NAMES = [
-    found_module
-    for found_module in find_submodules(CANVAS_TOP_LEVEL_MODULES)
-    # tests are excluded from the built and distributed module in pyproject.toml
-    if "tests" not in found_module and "test_" not in found_module
-]
-
-CANVAS_MODULES: dict[str, set[str]] = {}
-
-for module_name in CANVAS_SUBMODULE_NAMES:
-    module = importlib.import_module(module_name)
-
-    exports = getattr(module, "__exports__", None)
-
-    if not exports:
-        continue
-
-    if module_name not in CANVAS_MODULES:
-        CANVAS_MODULES[module_name] = set()
-
-    CANVAS_MODULES[module_name].update(exports)
-
-# In use by a current plugin...
-CANVAS_MODULES["canvas_sdk.commands"].add("*")
-
-
 STANDARD_LIBRARY_MODULES = {
     "__future__": {
         "annotations",
@@ -211,6 +161,7 @@ STANDARD_LIBRARY_MODULES = {
         "Literal",
         "NamedTuple",
         "NotRequired",
+        "Optional",
         "Protocol",
         "Sequence",
         "Tuple",
@@ -397,7 +348,47 @@ class Sandbox:
 
         def visit_AnnAssign(self, node: AnnAssign) -> AnnAssign:
             """Allow type annotations."""
-            return node
+            return self.node_contents_visit(node)
+
+        def visit_Match(self, node: ast.Match) -> ast.Match:
+            """Allow `match`."""
+            return self.node_contents_visit(node)
+
+        def visit_MatchAs(self, node: ast.MatchAs) -> ast.MatchAs:
+            """Allow `match`."""
+            return self.node_contents_visit(node)
+
+        def visit_MatchClass(self, node: ast.MatchClass) -> ast.MatchClass:
+            """Allow `match`."""
+            return self.node_contents_visit(node)
+
+        def visit_MatchMapping(self, node: ast.MatchMapping) -> ast.MatchMapping:
+            """Allow `match`."""
+            return self.node_contents_visit(node)
+
+        def visit_MatchOr(self, node: ast.MatchOr) -> ast.MatchOr:
+            """Allow `match`."""
+            return self.node_contents_visit(node)
+
+        def visit_MatchSingleton(self, node: ast.MatchSingleton) -> ast.MatchSingleton:
+            """Allow `match`."""
+            return self.node_contents_visit(node)
+
+        def visit_MatchSequence(self, node: ast.MatchSequence) -> ast.MatchSequence:
+            """Allow `match`."""
+            return self.node_contents_visit(node)
+
+        def visit_MatchStar(self, node: ast.MatchStar) -> ast.MatchStar:
+            """Allow `match`."""
+            return self.node_contents_visit(node)
+
+        def visit_MatchValue(self, node: ast.MatchValue) -> ast.MatchValue:
+            """Allow `match`."""
+            return self.node_contents_visit(node)
+
+        def visit_match_case(self, node: ast.match_case) -> ast.match_case:
+            """Allow `match`."""
+            return self.node_contents_visit(node)
 
         def check_import_names(self, node: ast.ImportFrom) -> ast.AST:
             """Check the names being imported.

protobufs/canvas_generated/messages/effects.proto

@@ -235,6 +235,12 @@ enum EffectType {
 
   ORIGINATE_CHART_SECTION_REVIEW_COMMAND = 1400;
 
+  ORIGINATE_IMMUNIZATION_STATEMENT_COMMAND = 1500;
+  EDIT_IMMUNIZATION_STATEMENT_COMMAND = 1501;
+  DELETE_IMMUNIZATION_STATEMENT_COMMAND = 1502;
+  COMMIT_IMMUNIZATION_STATEMENT_COMMAND = 1503;
+  ENTER_IN_ERROR_IMMUNIZATION_STATEMENT_COMMAND = 1504;
+
   SHOW_ACTION_BUTTON = 1000;
 
   PATIENT_PORTAL__FORM_RESULT = 2000;

protobufs/canvas_generated/messages/events.proto

@@ -54,6 +54,8 @@ enum EventType {
   PRESCRIPTION_UPDATED = 46;
   REFERRAL_REPORT_CREATED = 47;
   REFERRAL_REPORT_UPDATED = 48;
+  STAFF_CREATED = 49;
+  STAFF_UPDATED = 50;
   TASK_COMMENT_CREATED = 51;
   TASK_CREATED = 54;
   TASK_LABELS_ADJUSTED = 55;
@@ -98,6 +100,9 @@ enum EventType {
   DETECTED_ISSUE_EVIDENCE_CREATED = 88;
   DETECTED_ISSUE_EVIDENCE_UPDATED = 89;
 
+  STAFF_ACTIVATED = 90;
+  STAFF_DEACTIVATED = 91;
+
   // General Command Events
 
   PRE_COMMAND_ORIGINATE = 100;
@@ -1096,10 +1101,16 @@ enum EventType {
   SIMPLE_API_WEBSOCKET_AUTHENTICATE = 130002;
 
   PATIENT_METADATA__GET_ADDITIONAL_FIELDS = 140000;
-  
+
   PATIENT_EXTERNAL_IDENTIFIER_CREATED = 140001;
   PATIENT_EXTERNAL_IDENTIFIER_UPDATED = 140002;
   PATIENT_EXTERNAL_IDENTIFIER_DELETED = 140003;
+  PATIENT_METADATA_CREATED = 140004;
+  PATIENT_METADATA_UPDATED = 140005;
+
+  DOCUMENT_REFERENCE_CREATED = 150000;
+  DOCUMENT_REFERENCE_UPDATED = 150001;
+  DOCUMENT_REFERENCE_DELETED = 150002;
 }
 
 message Event {

settings.py

@@ -2,14 +2,17 @@ import logging
 import os
 import sys
 from pathlib import Path
+from typing import Any
 from urllib import parse
 
+from django.core.exceptions import ImproperlyConfigured
 from dotenv import load_dotenv
 from env_tools import env_to_bool
 
 load_dotenv()
 
 BASE_DIR = Path(__file__).resolve().parent.resolve()
+
 FOURTEEN_DAYS = 60 * 60 * 24 * 14
 
 ENV = os.getenv("ENV", "development")
@@ -62,35 +65,66 @@ CANVAS_SDK_DB_USERNAME = os.getenv("CANVAS_SDK_DB_USERNAME", "app")
 CANVAS_SDK_DB_PASSWORD = os.getenv("CANVAS_SDK_DB_PASSWORD", "app")
 CANVAS_SDK_DB_HOST = os.getenv("CANVAS_SDK_DB_HOST", "home-app-db")
 CANVAS_SDK_DB_PORT = os.getenv("CANVAS_SDK_DB_PORT", "5432")
+CANVAS_SDK_DB_URL = os.getenv("DATABASE_URL")
+
+if IS_TESTING:
+    CANVAS_SDK_DB_BACKEND = "sqlite3"
+elif CANVAS_SDK_DB_URL:
+    CANVAS_SDK_DB_BACKEND = "postgres"
+else:
+    # Default to sqlite3 for local development if no DATABASE_URL is set
+    CANVAS_SDK_DB_BACKEND = "sqlite3" if IS_SCRIPT else "postgres"
 
 PLUGIN_RUNNER_MAX_WORKERS = int(os.getenv("PLUGIN_RUNNER_MAX_WORKERS", 5))
 
-if os.getenv("DATABASE_URL"):
-    parsed_url = parse.urlparse(os.getenv("DATABASE_URL"))
+if CANVAS_SDK_DB_BACKEND == "postgres":
+    db_config: dict[str, Any] = {
+        "ENGINE": "django.db.backends.postgresql",
+        "OPTIONS": {"pool": {"min_size": 2, "max_size": PLUGIN_RUNNER_MAX_WORKERS}},
+    }
 
+    if CANVAS_SDK_DB_URL:
+        parsed_url = parse.urlparse(CANVAS_SDK_DB_URL)
+        db_config.update(
+            {
+                "NAME": parsed_url.path[1:],
+                "USER": os.getenv("CANVAS_SDK_DATABASE_ROLE"),
+                "PASSWORD": os.getenv("CANVAS_SDK_DATABASE_ROLE_PASSWORD"),
+                "HOST": parsed_url.hostname,
+                "PORT": parsed_url.port,
+            }
+        )
+    else:
+        db_config.update(
+            {
+                "NAME": CANVAS_SDK_DB_NAME,
+                "USER": CANVAS_SDK_DB_USERNAME,
+                "PASSWORD": CANVAS_SDK_DB_PASSWORD,
+                "HOST": CANVAS_SDK_DB_HOST,
+                "PORT": CANVAS_SDK_DB_PORT,
+            }
+        )
+
+    DATABASES = {"default": db_config}
+
+elif CANVAS_SDK_DB_BACKEND == "sqlite3":
     DATABASES = {
         "default": {
-            "ENGINE": "django.db.backends.postgresql",
-            "OPTIONS": {"pool": {"min_size": 2, "max_size": PLUGIN_RUNNER_MAX_WORKERS}},
-            "NAME": parsed_url.path[1:],
-            "USER": os.getenv("CANVAS_SDK_DATABASE_ROLE"),
-            "PASSWORD": os.getenv("CANVAS_SDK_DATABASE_ROLE_PASSWORD"),
-            "HOST": parsed_url.hostname,
-            "PORT": parsed_url.port,
-        }
+            "ENGINE": "django.db.backends.sqlite3",
+            "NAME": f"file:{str(BASE_DIR / 'db.sqlite3')}?mode=ro",
+            "OPTIONS": {"uri": True},
+        },
+        "default-write": {
+            "ENGINE": "django.db.backends.sqlite3",
+            "NAME": str(BASE_DIR / "db.sqlite3"),
+        },
     }
+
 else:
-    DATABASES = {
-        "default": {
-            "ENGINE": "django.db.backends.postgresql",
-            "OPTIONS": {"pool": {"min_size": 2, "max_size": PLUGIN_RUNNER_MAX_WORKERS}},
-            "NAME": CANVAS_SDK_DB_NAME,
-            "USER": CANVAS_SDK_DB_USERNAME,
-            "PASSWORD": CANVAS_SDK_DB_PASSWORD,
-            "HOST": CANVAS_SDK_DB_HOST,
-            "PORT": CANVAS_SDK_DB_PORT,
-        }
-    }
+    raise ImproperlyConfigured(
+        "Unsupported database backend specified in 'CANVAS_SDK_DB_BACKEND' setting. "
+        "Supported values are 'postgres' and 'sqlite3'."
+    )
 
 AWS_ACCESS_KEY_ID = os.getenv("AWS_ACCESS_KEY_ID", "")
 AWS_SECRET_ACCESS_KEY = os.getenv("AWS_SECRET_ACCESS_KEY", "")
@@ -129,7 +163,7 @@ TEMPLATES = [
 ]
 
 
-if IS_TESTING:
+if IS_SCRIPT:
     CACHES = {
         "default": {
             "BACKEND": "django.core.cache.backends.locmem.LocMemCache",