canvas 0.3.1__py3-none-any.whl → 0.5.0__py3-none-any.whl

canvas_sdk/value_set/v2022/intervention.py

@@ -1,30 +1,6 @@
 from ..value_set import ValueSet
 
 
-class HospiceCareAmbulatory(ValueSet):
-    """
-    **Clinical Focus:** The purpose of this value set is to represent concepts of interventions to identify patients receiving hospice care outside of a hospital or long term care facility.
-
-    **Data Element Scope:** This value set may use a model element related to Procedure or Intervention.
-
-    **Inclusion Criteria:** Includes concepts that represent a procedure or intervention for hospice care.
-
-    **Exclusion Criteria:** Excludes concepts that represent palliative care or comfort measures.
-
-    ** Used in:** CMS90v11, CMS134v10, CMS165v10, CMS146v10, CMS124v10, CMS139v10, CMS154v10, CMS56v10, CMS74v11, CMS75v10, CMS137v10, CMS136v11, CMS128v10, CMS122v10, CMS153v10, CMS66v10, CMS130v10, CMS155v10, CMS127v10, CMS117v10, CMS131v10, CMS156v10, CMS125v10
-    """
-
-    VALUE_SET_NAME = "Hospice care ambulatory"
-    OID = "2.16.840.1.113762.1.4.1108.15"
-    DEFINITION_VERSION = "20170504"
-    EXPANSION_VERSION = "eCQM Update 2021-05-06"
-
-    SNOMEDCT = {
-        "385763009",  # Hospice care (regime/therapy)
-        "385765002",  # Hospice care management (procedure)
-    }
-
-
 class PalliativeCareIntervention(ValueSet):
     """
     **Clinical Focus:** The purpose of this value set is to represent concepts for palliative care interventions.

canvas_sdk/value_set/value_set.py

@@ -1,5 +1,7 @@
 from collections import defaultdict
-from typing import Dict, Union, cast
+from typing import Union, cast
+
+from django.utils.functional import classproperty
 
 
 class CodeConstants:
@@ -33,7 +35,7 @@ class CodeConstants:
     URL_NDC = "http://hl7.org/fhir/sid/ndc"
 
 
-class CodeConstantsURLMapping:
+class CodeConstantsURLMappingMixin:
     """A class that maps code systems to their URLs."""
 
     CODE_SYSTEM_MAPPING = {
@@ -53,21 +55,21 @@ class CodeConstantsURLMapping:
     }
 
 
-class CombinedValueSet(CodeConstantsURLMapping):
+class CombinedValueSet(CodeConstantsURLMappingMixin):
     """A class representing a combination of two value sets."""
 
     def __init__(
         self,
-        value_set_1: Union["ValueSet", "CombinedValueSet"],
-        value_set_2: Union["ValueSet", "CombinedValueSet"],
+        value_set_1: Union[type["ValueSet"], "CombinedValueSet"],
+        value_set_2: Union[type["ValueSet"], "CombinedValueSet"],
     ) -> None:
         self.value_set_1 = value_set_1
         self.value_set_2 = value_set_2
 
     @property
-    def values(self) -> Dict[str, set]:
+    def values(self) -> dict[str, set]:
         """A property that returns the combined values from both value sets."""
-        values: Dict[str, set] = defaultdict(set)
+        values: dict[str, set] = defaultdict(set)
 
         for vs in [self.value_set_1, self.value_set_2]:
             sub_values = vs.values
@@ -77,7 +79,7 @@ class CombinedValueSet(CodeConstantsURLMapping):
 
         return values
 
-    def __or__(self, value_set: Union["ValueSet", "CombinedValueSet"]) -> "CombinedValueSet":
+    def __or__(self, value_set: Union[type["ValueSet"], "CombinedValueSet"]) -> "CombinedValueSet":
         """Implements the `|` (or) operator to combine value sets."""
         return CombinedValueSet(self, value_set)
 
@@ -85,22 +87,23 @@ class CombinedValueSet(CodeConstantsURLMapping):
 class ValueSystems(type):
     """A metaclass for defining a ValueSet."""
 
-    @property
-    def values(cls) -> dict[str, set]:
-        """A property that returns a dictionary of code systems and their associated values."""
-        return {
-            system: getattr(cls, system)
-            for system in cast(ValueSet, cls).CODE_SYSTEM_MAPPING.keys()
-            if hasattr(cls, system)
-        }
+    def __or__(self, value_set: Union[type["ValueSet"], "CombinedValueSet"]) -> "CombinedValueSet":  # type: ignore[override]
+        """Implements the `|` (or) operator."""
+        return CombinedValueSet(cast(type["ValueSet"], self), value_set)
 
-    def __or__(self, value_set: Union["ValueSet", "CombinedValueSet"]) -> CombinedValueSet:  # type: ignore[override]
+    def __ror__(self, value_set: Union[type["ValueSet"], "CombinedValueSet"]) -> "CombinedValueSet":  # type: ignore[override]
         """Implements the `|` (or) operator."""
-        return CombinedValueSet(cast(ValueSet, self), value_set)
+        return self.__or__(value_set)
 
 
-class ValueSet(CodeConstantsURLMapping, metaclass=ValueSystems):
+class ValueSet(CodeConstantsURLMappingMixin, metaclass=ValueSystems):
     """The Base class for a ValueSet."""
 
-    values: dict[str, set]
-    pass
+    @classproperty
+    def values(cls) -> dict[str, set]:
+        """A property that returns a dictionary of code systems and their associated values."""
+        return {
+            system: getattr(cls, system)
+            for system in cls.CODE_SYSTEM_MAPPING.keys()
+            if hasattr(cls, system)
+        }

plugin_runner/authentication.py

@@ -1,23 +1,19 @@
 import os
-from typing import cast
 
 import arrow
 from jwt import encode
 
 from logger import log
+from settings import PLUGIN_RUNNER_SIGNING_KEY
 
 ONE_DAY_IN_MINUTES = 60 * 24
 
-INSECURE_DEFAULT_SIGNING_KEY = "INSECURE_KEY"
-
 
 def token_for_plugin(
     plugin_name: str,
     audience: str,
     issuer: str = "plugin-runner",
-    jwt_signing_key: str = cast(
-        str, os.getenv("PLUGIN_RUNNER_SIGNING_KEY", INSECURE_DEFAULT_SIGNING_KEY)
-    ),
+    jwt_signing_key: str = PLUGIN_RUNNER_SIGNING_KEY,
     expiration_minutes: int = ONE_DAY_IN_MINUTES,
     extra_kwargs: dict | None = None,
 ) -> str:
@@ -27,7 +23,7 @@ def token_for_plugin(
     if not extra_kwargs:
         extra_kwargs = {}
 
-    if jwt_signing_key == INSECURE_DEFAULT_SIGNING_KEY:
+    if not jwt_signing_key:
         log.warning(
             "Using an insecure JWT signing key for GraphQL access. Set the PLUGIN_RUNNER_SIGNING_KEY environment variable to avoid this message."
         )

plugin_runner/plugin_runner.py

@@ -1,15 +1,15 @@
 import asyncio
-import importlib.util
 import json
 import os
 import pathlib
+import pkgutil
 import signal
 import sys
 import time
 import traceback
 from collections import defaultdict
 from types import FrameType
-from typing import Any, Optional
+from typing import Any, AsyncGenerator, Optional, TypedDict
 
 import grpc
 import statsd
@@ -30,17 +30,7 @@ from logger import log
 from plugin_runner.authentication import token_for_plugin
 from plugin_runner.plugin_synchronizer import publish_message
 from plugin_runner.sandbox import Sandbox
-
-ENV = os.getenv("ENV", "development")
-
-IS_PRODUCTION = ENV == "production"
-
-MANIFEST_FILE_NAME = "CANVAS_MANIFEST.json"
-
-SECRETS_FILE_NAME = "SECRETS.json"
-
-# specify a local plugin directory for development
-PLUGIN_DIRECTORY = "/plugin-runner/custom-plugins" if IS_PRODUCTION else "./custom-plugins"
+from settings import MANIFEST_FILE_NAME, PLUGIN_DIRECTORY, 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
@@ -51,7 +41,50 @@ sys.path.append(PLUGIN_DIRECTORY)
 LOADED_PLUGINS: dict = {}
 
 # a global dictionary of events to protocol class names
-EVENT_PROTOCOL_MAP: dict = {}
+EVENT_PROTOCOL_MAP: dict[str, list] = defaultdict(list)
+
+
+class DataAccess(TypedDict):
+    """DataAccess."""
+
+    event: str
+    read: list[str]
+    write: list[str]
+
+
+Protocol = TypedDict(
+    "Protocol",
+    {
+        "class": str,
+        "data_access": DataAccess,
+    },
+)
+
+
+class Components(TypedDict):
+    """Components."""
+
+    protocols: list[Protocol]
+    commands: list[dict]
+    content: list[dict]
+    effects: list[dict]
+    views: list[dict]
+
+
+class PluginManifest(TypedDict):
+    """PluginManifest."""
+
+    sdk_version: str
+    plugin_version: str
+    name: str
+    description: str
+    components: Components
+    secrets: list[dict]
+    tags: dict[str, str]
+    references: list[str]
+    license: str
+    diagram: bool
+    readme: str
 
 
 class PluginRunner(PluginRunnerServicer):
@@ -63,11 +96,19 @@ class PluginRunner(PluginRunnerServicer):
 
     sandbox: Sandbox
 
-    async def HandleEvent(self, request: Event, context: Any) -> EventResponse:
+    async def HandleEvent(
+        self, request: Event, context: Any
+    ) -> AsyncGenerator[EventResponse, None]:
         """This is invoked when an event comes in."""
         event_start_time = time.time()
-        event_name = EventType.Name(request.type)
-        relevant_plugins = EVENT_PROTOCOL_MAP.get(event_name, [])
+        event_type = request.type
+        event_name = EventType.Name(event_type)
+        relevant_plugins = EVENT_PROTOCOL_MAP[event_name]
+
+        if event_type in [EventType.PLUGIN_CREATED, EventType.PLUGIN_UPDATED]:
+            plugin_name = request.target
+            # filter only for the plugin(s) that were created/updated
+            relevant_plugins = [p for p in relevant_plugins if p.startswith(f"{plugin_name}:")]
 
         effect_list = []
 
@@ -129,7 +170,7 @@ class PluginRunner(PluginRunnerServicer):
 
     async def ReloadPlugins(
         self, request: ReloadPluginsRequest, context: Any
-    ) -> ReloadPluginsResponse:
+    ) -> AsyncGenerator[ReloadPluginsResponse, None]:
         """This is invoked when we need to reload plugins."""
         try:
             load_plugins()
@@ -146,18 +187,50 @@ def handle_hup_cb(_signum: int, _frame: Optional[FrameType]) -> None:
     load_plugins()
 
 
-def sandbox_from_module_name(module_name: str) -> Any:
+def find_modules(base_path: pathlib.Path, prefix: str | None = None) -> list[str]:
+    """Find all modules in the specified package path."""
+    modules: list[str] = []
+
+    for file_finder, module_name, is_pkg in pkgutil.iter_modules(
+        [base_path.as_posix()],
+    ):
+        if is_pkg:
+            modules = modules + find_modules(
+                base_path / module_name,
+                prefix=f"{prefix}.{module_name}" if prefix else module_name,
+            )
+        else:
+            modules.append(f"{prefix}.{module_name}" if prefix else module_name)
+
+    return modules
+
+
+def sandbox_from_package(package_path: pathlib.Path) -> dict[str, Any]:
+    """Sandbox the code execution."""
+    package_name = package_path.name
+    available_modules = find_modules(package_path)
+    sandboxes = {}
+
+    for module_name in available_modules:
+        result = sandbox_from_module(package_path, module_name)
+        full_module_name = f"{package_name}.{module_name}"
+        sandboxes[full_module_name] = result
+
+    return sandboxes
+
+
+def sandbox_from_module(package_path: pathlib.Path, module_name: str) -> Any:
     """Sandbox the code execution."""
-    spec = importlib.util.find_spec(module_name)
+    module_path = package_path / str(module_name.replace(".", "/") + ".py")
 
-    if not spec or not spec.origin:
-        raise Exception(f'Could not load plugin "{module_name}"')
+    if not module_path.exists():
+        raise ModuleNotFoundError(f'Could not load module "{module_name}"')
 
-    origin = pathlib.Path(spec.origin)
-    source_code = origin.read_text()
+    source_code = module_path.read_text()
 
-    sandbox = Sandbox(source_code)
+    full_module_name = f"{package_path.name}.{module_name}"
 
+    sandbox = Sandbox(source_code, module_name=full_module_name)
     return sandbox.execute()
 
 
@@ -166,13 +239,13 @@ def load_or_reload_plugin(path: pathlib.Path) -> None:
     log.info(f"Loading {path}")
 
     manifest_file = path / MANIFEST_FILE_NAME
-    manifest_json = manifest_file.read_text()
+    manifest_json_str = manifest_file.read_text()
 
     # the name is the folder name underneath the plugins directory
     name = path.name
 
     try:
-        manifest_json = json.loads(manifest_json)
+        manifest_json: PluginManifest = json.loads(manifest_json_str)
     except Exception as e:
         log.error(f'Unable to load plugin "{name}": {e}')
         return
@@ -189,6 +262,7 @@ def load_or_reload_plugin(path: pathlib.Path) -> None:
     # TODO add existing schema validation from Michela here
     try:
         protocols = manifest_json["components"]["protocols"]
+        results = sandbox_from_package(path)
     except Exception as e:
         log.error(f'Unable to load plugin "{name}": {str(e)}')
         return
@@ -207,7 +281,7 @@ def load_or_reload_plugin(path: pathlib.Path) -> None:
             if name_and_class in LOADED_PLUGINS:
                 log.info(f"Reloading plugin '{name_and_class}'")
 
-                result = sandbox_from_module_name(protocol_module)
+                result = results[protocol_module]
 
                 LOADED_PLUGINS[name_and_class]["active"] = True
 
@@ -217,7 +291,7 @@ def load_or_reload_plugin(path: pathlib.Path) -> None:
             else:
                 log.info(f"Loading plugin '{name_and_class}'")
 
-                result = sandbox_from_module_name(protocol_module)
+                result = results[protocol_module]
 
                 LOADED_PLUGINS[name_and_class] = {
                     "active": True,
@@ -234,8 +308,7 @@ def load_or_reload_plugin(path: pathlib.Path) -> None:
 
 def refresh_event_type_map() -> None:
     """Ensure the event subscriptions are up to date."""
-    global EVENT_PROTOCOL_MAP
-    EVENT_PROTOCOL_MAP = defaultdict(list)
+    EVENT_PROTOCOL_MAP.clear()
 
     for name, plugin in LOADED_PLUGINS.items():
         if hasattr(plugin["class"], "RESPONDS_TO"):
@@ -264,8 +337,8 @@ def load_plugins(specified_plugin_paths: list[str] | None = None) -> None:
         for plugin_path in plugin_paths:
             # when we import plugins we'll use the module name directly so we need to add the plugin
             # directory to the path
-            path_to_append = f"./{plugin_path.parent}"
-            sys.path.append(path_to_append)
+            path_to_append = pathlib.Path(".") / plugin_path.parent
+            sys.path.append(path_to_append.as_posix())
     else:
         candidates = os.listdir(PLUGIN_DIRECTORY)
 

plugin_runner/sandbox.py

@@ -75,12 +75,6 @@ def _is_known_module(name: str) -> bool:
     return any(name.startswith(m) for m in ALLOWED_MODULES)
 
 
-def _safe_import(name: str, *args: Any, **kwargs: Any) -> Any:
-    if not _is_known_module(name):
-        raise ImportError(f"{name!r} is not an allowed import.")
-    return __import__(name, *args, **kwargs)
-
-
 def _unrestricted(_ob: Any, *args: Any, **kwargs: Any) -> Any:
     """Return the given object, unmodified."""
     return _ob
@@ -96,6 +90,7 @@ class Sandbox:
 
     source_code: str
     namespace: str
+    module_name: str | None
 
     class Transformer(RestrictingNodeTransformer):
         """A node transformer for customizing the sandbox compiler."""
@@ -113,7 +108,7 @@ class Sandbox:
             => 'from _a import x' is ok, because '_a' is not added to the scope.
             """
             for name in node.names:
-                if "*" in name.name and not _is_known_module(node.module):
+                if "*" in name.name and node.module and not _is_known_module(node.module):
                     self.error(node, '"*" imports are not allowed.')
                 self.check_name(node, name.name)
                 if name.asname:
@@ -204,12 +199,20 @@ class Sandbox:
                 # Impossible Case only ctx Load, Store and Del are defined in ast.
                 raise NotImplementedError(f"Unknown ctx type: {type(node.ctx)}")
 
-    def __init__(self, source_code: str, namespace: str | None = None) -> None:
+    def __init__(
+        self, source_code: str, namespace: str | None = None, module_name: str | None = None
+    ) -> None:
         if source_code is None:
             raise TypeError("source_code may not be None")
+        self.module_name = module_name
         self.namespace = namespace or "protocols"
         self.source_code = source_code
 
+    @cached_property
+    def package_name(self) -> str | None:
+        """Return the root package name."""
+        return self.module_name.split(".")[0] if self.module_name else None
+
     @cached_property
     def scope(self) -> dict[str, Any]:
         """Return the scope used for evaluation."""
@@ -217,7 +220,7 @@ class Sandbox:
             "__builtins__": {
                 **safe_builtins.copy(),
                 **utility_builtins.copy(),
-                "__import__": _safe_import,
+                "__import__": self._safe_import,
                 "classmethod": builtins.classmethod,
                 "staticmethod": builtins.staticmethod,
                 "any": builtins.any,
@@ -263,6 +266,17 @@ class Sandbox:
         """Return warnings encountered when compiling the source code."""
         return cast(tuple[str, ...], self.compile_result.warnings)
 
+    def _is_known_module(self, name: str) -> bool:
+        return bool(
+            _is_known_module(name)
+            or (self.package_name and name.split(".")[0] == self.package_name)
+        )
+
+    def _safe_import(self, name: str, *args: Any, **kwargs: Any) -> Any:
+        if not (self._is_known_module(name)):
+            raise ImportError(f"{name!r} is not an allowed import.")
+        return __import__(name, *args, **kwargs)
+
     def execute(self) -> dict:
         """Execute the given code in a restricted sandbox."""
         if self.errors:

plugin_runner/tests/fixtures/plugins/example_plugin/CANVAS_MANIFEST.json

@@ -0,0 +1,29 @@
+{
+    "sdk_version": "0.1.4",
+    "plugin_version": "0.0.1",
+    "name": "example_plugin",
+    "description": "Edit the description in CANVAS_MANIFEST.json",
+    "components": {
+        "protocols": [
+            {
+                "class": "example_plugin.protocols.my_protocol:Protocol",
+                "description": "A protocol that does xyz...",
+                "data_access": {
+                    "event": "",
+                    "read": [],
+                    "write": []
+                }
+            }
+        ],
+        "commands": [],
+        "content": [],
+        "effects": [],
+        "views": []
+    },
+    "secrets": [],
+    "tags": {},
+    "references": [],
+    "license": "",
+    "diagram": false,
+    "readme": "./README.md"
+}

plugin_runner/tests/fixtures/plugins/example_plugin/README.md

@@ -0,0 +1,12 @@
+==============
+example_plugin
+==============
+
+## Description
+
+A description of this plugin
+
+### Important Note!
+
+The CANVAS_MANIFEST.json is used when installing your plugin. Please ensure it
+gets updated if you add, remove, or rename protocols.

plugin_runner/tests/fixtures/plugins/example_plugin/protocols/my_protocol.py

@@ -0,0 +1,18 @@
+from canvas_sdk.effects import Effect, EffectType
+from canvas_sdk.events import EventType
+from canvas_sdk.protocols import BaseProtocol
+
+
+class Protocol(BaseProtocol):
+    """
+    You should put a helpful description of this protocol's behavior here.
+    """
+
+    # Name the event type you wish to run in response to
+    RESPONDS_TO = EventType.Name(EventType.UNKNOWN)
+
+    NARRATIVE_STRING = "I was inserted from my plugin's protocol."
+
+    def compute(self) -> list[Effect]:
+        """This method gets called when an event of the type RESPONDS_TO is fired."""
+        return [Effect(type=EffectType.LOG, payload="Hello, world!")]

plugin_runner/tests/fixtures/plugins/test_module_imports_outside_plugin_v1/CANVAS_MANIFEST.json

@@ -0,0 +1,29 @@
+{
+    "sdk_version": "0.1.4",
+    "plugin_version": "0.0.1",
+    "name": "test_module_imports_outside_plugin_v1",
+    "description": "Edit the description in CANVAS_MANIFEST.json",
+    "components": {
+        "protocols": [
+            {
+                "class": "test_module_imports_outside_plugin_v1.protocols.my_protocol:Protocol",
+                "description": "A protocol that does xyz...",
+                "data_access": {
+                    "event": "",
+                    "read": [],
+                    "write": []
+                }
+            }
+        ],
+        "commands": [],
+        "content": [],
+        "effects": [],
+        "views": []
+    },
+    "secrets": [],
+    "tags": {},
+    "references": [],
+    "license": "",
+    "diagram": false,
+    "readme": "./README.md"
+}

plugin_runner/tests/fixtures/plugins/test_module_imports_outside_plugin_v1/README.md

@@ -0,0 +1,12 @@
+==========================
+test_module_imports_outside_plugin_v1
+==========================
+
+## Description
+
+A description of this plugin
+
+### Important Note!
+
+The CANVAS_MANIFEST.json is used when installing your plugin. Please ensure it
+gets updated if you add, remove, or rename protocols.

plugin_runner/tests/fixtures/plugins/test_module_imports_outside_plugin_v1/other_module/base.py

@@ -0,0 +1,3 @@
+def import_me() -> str:
+    """Test method."""
+    return "Successfully imported!"

plugin_runner/tests/fixtures/plugins/test_module_imports_outside_plugin_v1/protocols/my_protocol.py

@@ -0,0 +1,18 @@
+from test_module_imports_plugin.other_module.base import import_me
+
+from canvas_sdk.effects import Effect, EffectType
+from canvas_sdk.events import EventType
+from canvas_sdk.protocols import BaseProtocol
+
+
+class Protocol(BaseProtocol):
+    """
+    You should put a helpful description of this protocol's behavior here.
+    """
+
+    # Name the event type you wish to run in response to
+    RESPONDS_TO = EventType.Name(EventType.UNKNOWN)
+
+    def compute(self) -> list[Effect]:
+        """This method gets called when an event of the type RESPONDS_TO is fired."""
+        return [Effect(type=EffectType.LOG, payload=import_me())]

plugin_runner/tests/fixtures/plugins/test_module_imports_outside_plugin_v2/CANVAS_MANIFEST.json

@@ -0,0 +1,29 @@
+{
+    "sdk_version": "0.1.4",
+    "plugin_version": "0.0.1",
+    "name": "test_module_imports_outside_plugin_v2",
+    "description": "Edit the description in CANVAS_MANIFEST.json",
+    "components": {
+        "protocols": [
+            {
+                "class": "test_module_imports_outside_plugin_v2.protocols.my_protocol:Protocol",
+                "description": "A protocol that does xyz...",
+                "data_access": {
+                    "event": "",
+                    "read": [],
+                    "write": []
+                }
+            }
+        ],
+        "commands": [],
+        "content": [],
+        "effects": [],
+        "views": []
+    },
+    "secrets": [],
+    "tags": {},
+    "references": [],
+    "license": "",
+    "diagram": false,
+    "readme": "./README.md"
+}

plugin_runner/tests/fixtures/plugins/test_module_imports_outside_plugin_v2/README.md

@@ -0,0 +1,12 @@
+==========================
+test_module_imports_outside_plugin_v2
+==========================
+
+## Description
+
+A description of this plugin
+
+### Important Note!
+
+The CANVAS_MANIFEST.json is used when installing your plugin. Please ensure it
+gets updated if you add, remove, or rename protocols.

plugin_runner/tests/fixtures/plugins/test_module_imports_outside_plugin_v2/other_module/base.py

@@ -0,0 +1,6 @@
+import os
+
+
+def import_me() -> list[str]:
+    """Test method."""
+    return os.listdir(".")