canvas 0.13.3__py3-none-any.whl → 0.15.0__py3-none-any.whl

canvas_sdk/v1/data/questionnaire.py

@@ -3,12 +3,10 @@ from collections.abc import Container
 from django.db import models
 from django.db.models import Q
 
-from canvas_sdk.v1.data import Patient
 from canvas_sdk.v1.data.base import (
     CommittableModelManager,
     ValueSetLookupByNameQuerySet,
 )
-from canvas_sdk.v1.data.user import CanvasUser
 
 
 class ResponseOptionSet(models.Model):
@@ -16,7 +14,6 @@ class ResponseOptionSet(models.Model):
 
     class Meta:
         managed = False
-        app_label = "canvas_sdk"
         db_table = "canvas_sdk_data_api_responseoptionset_001"
 
     dbid = models.BigIntegerField(primary_key=True)
@@ -35,7 +32,6 @@ class ResponseOption(models.Model):
 
     class Meta:
         managed = False
-        app_label = "canvas_sdk"
         db_table = "canvas_sdk_data_api_responseoption_001"
 
     dbid = models.BigIntegerField(primary_key=True)
@@ -57,7 +53,6 @@ class Question(models.Model):
 
     class Meta:
         managed = False
-        app_label = "canvas_sdk"
         db_table = "canvas_sdk_data_api_question_001"
 
     id = models.UUIDField()
@@ -89,7 +84,6 @@ class Questionnaire(models.Model):
 
     class Meta:
         managed = False
-        app_label = "canvas_sdk"
         db_table = "canvas_sdk_data_api_questionnaire_001"
 
     objects = models.Manager.from_queryset(QuestionnaireValueSetLookupQuerySet)()
@@ -109,7 +103,7 @@ class Questionnaire(models.Model):
     code_system = models.CharField()
     code = models.CharField()
     search_tags = models.CharField()
-    questions = models.ManyToManyField(Question, through="canvas_sdk.QuestionnaireQuestionMap")  # type: ignore[misc, var-annotated]
+    questions = models.ManyToManyField(Question, through="v1.QuestionnaireQuestionMap")  # type: ignore[misc, var-annotated]
     use_in_shx = models.BooleanField()
     carry_forward = models.TextField()
 
@@ -119,7 +113,6 @@ class QuestionnaireQuestionMap(models.Model):
 
     class Meta:
         managed = False
-        app_label = "canvas_sdk"
         db_table = "canvas_sdk_data_api_questionnairequestionmap_001"
 
     dbid = models.BigIntegerField(primary_key=True)
@@ -135,7 +128,6 @@ class Interview(models.Model):
 
     class Meta:
         managed = False
-        app_label = "canvas_sdk"
         db_table = "canvas_sdk_data_api_interview_001"
 
     objects = CommittableModelManager()
@@ -143,20 +135,20 @@ class Interview(models.Model):
     id = models.UUIDField()
     dbid = models.BigIntegerField(primary_key=True)
     deleted = models.BooleanField()
-    committer = models.ForeignKey(CanvasUser, on_delete=models.DO_NOTHING, null=True)
-    entered_in_error = models.ForeignKey(CanvasUser, on_delete=models.DO_NOTHING, null=True)
+    committer = models.ForeignKey("v1.CanvasUser", on_delete=models.DO_NOTHING, null=True)
+    entered_in_error = models.ForeignKey("v1.CanvasUser", on_delete=models.DO_NOTHING, null=True)
     status = models.CharField()
     name = models.CharField()
     language_id = models.BigIntegerField()
     use_case_in_charting = models.CharField()
     patient = models.ForeignKey(
-        Patient, on_delete=models.DO_NOTHING, related_name="interviews", null=True
+        "v1.Patient", on_delete=models.DO_NOTHING, related_name="interviews", null=True
     )
     note_id = models.BigIntegerField()
     appointment_id = models.BigIntegerField()
     questionnaires = models.ManyToManyField(  # type: ignore[var-annotated]
         Questionnaire,
-        through="canvas_sdk.InterviewQuestionnaireMap",  # type: ignore[misc]
+        through="v1.InterviewQuestionnaireMap",  # type: ignore[misc]
     )
     progress_status = models.CharField()
     created = models.DateTimeField()
@@ -168,7 +160,6 @@ class InterviewQuestionnaireMap(models.Model):
 
     class Meta:
         managed = False
-        app_label = "canvas_sdk"
         db_table = "canvas_sdk_data_api_interviewquestionnairemap_001"
 
     dbid = models.BigIntegerField(primary_key=True)
@@ -184,7 +175,6 @@ class InterviewQuestionResponse(models.Model):
 
     class Meta:
         managed = False
-        app_label = "canvas_sdk"
         db_table = "canvas_sdk_data_api_interviewquestionresponse_001"
 
     dbid = models.BigIntegerField(primary_key=True)

canvas_sdk/v1/data/staff.py

@@ -3,7 +3,6 @@ from django.db import models
 from timezone_utils.fields import TimeZoneField
 
 from canvas_sdk.v1.data.common import PersonSex, TaxIDType
-from canvas_sdk.v1.data.user import CanvasUser
 
 
 class Staff(models.Model):
@@ -11,7 +10,6 @@ class Staff(models.Model):
 
     class Meta:
         managed = False
-        app_label = "canvas_sdk"
         db_table = "canvas_sdk_data_api_staff_001"
 
     def __str__(self) -> str:
@@ -44,7 +42,7 @@ class Staff(models.Model):
     active = models.BooleanField()
     # TODO - uncomment when PracticeLocation field is developed
     # primary_practice_location = models.ForeignKey(
-    #     PracticeLocation, on_delete=models.DO_NOTHING, null=True
+    #     'v1.PracticeLocation', on_delete=models.DO_NOTHING, null=True
     # )
     npi_number = models.CharField()
     nadean_number = models.CharField()
@@ -54,12 +52,12 @@ class Staff(models.Model):
     tax_id_type = models.CharField(choices=TaxIDType.choices)
     spi_number = models.CharField()
     # TODO - uncomment when Language is developed
-    # language = models.ForeignKey(Language, on_delete=models.DO_NOTHING, related_name="staff_speakers", null=True)
-    # language_secondary = models.ForeignKey(Language, on_delete=models.DO_NOTHING, related_name="staff_secondary_speakers", null=True)
+    # language = models.ForeignKey('v1.Language', on_delete=models.DO_NOTHING, related_name="staff_speakers", null=True)
+    # language_secondary = models.ForeignKey('v1.Language', on_delete=models.DO_NOTHING, related_name="staff_secondary_speakers", null=True)
     personal_meeting_room_link = models.URLField(null=True)
     state = models.JSONField()
-    user = models.ForeignKey(CanvasUser, on_delete=models.DO_NOTHING, null=True)
+    user = models.ForeignKey("v1.CanvasUser", on_delete=models.DO_NOTHING, null=True)
     schedule_column_ordering = models.IntegerField()
     default_supervising_provider = models.ForeignKey(
-        "Staff", on_delete=models.DO_NOTHING, related_name="supervising_team", null=True
+        "v1.Staff", on_delete=models.DO_NOTHING, related_name="supervising_team", null=True
     )

canvas_sdk/v1/data/task.py

@@ -2,8 +2,6 @@ from django.contrib.postgres.fields import ArrayField
 from django.db import models
 
 from canvas_sdk.v1.data.common import ColorEnum, Origin
-from canvas_sdk.v1.data.patient import Patient
-from canvas_sdk.v1.data.staff import Staff
 
 
 class TaskType(models.TextChoices):
@@ -39,7 +37,6 @@ class Task(models.Model):
 
     class Meta:
         managed = False
-        app_label = "canvas_sdk"
         db_table = "canvas_sdk_data_api_task_001"
 
     id = models.UUIDField()
@@ -47,15 +44,15 @@ class Task(models.Model):
     created = models.DateTimeField()
     modified = models.DateTimeField()
     creator = models.ForeignKey(
-        Staff, on_delete=models.DO_NOTHING, related_name="creator_tasks", null=True
+        "v1.Staff", on_delete=models.DO_NOTHING, related_name="creator_tasks", null=True
     )
     assignee = models.ForeignKey(
-        Staff, on_delete=models.DO_NOTHING, related_name="assignee_tasks", null=True
+        "v1.Staff", on_delete=models.DO_NOTHING, related_name="assignee_tasks", null=True
     )
     # TODO - uncomment when Team model is created
-    # team = models.ForeignKey(Team, on_delete=models.DO_NOTHING, related_name="tasks", null=True)
+    # team = models.ForeignKey('v1.Team', on_delete=models.DO_NOTHING, related_name="tasks", null=True)
     patient = models.ForeignKey(
-        Patient, on_delete=models.DO_NOTHING, blank=True, related_name="tasks", null=True
+        "v1.Patient", on_delete=models.DO_NOTHING, blank=True, related_name="tasks", null=True
     )
     task_type = models.CharField(choices=TaskType.choices)
     tag = models.CharField()
@@ -70,7 +67,6 @@ class TaskComment(models.Model):
 
     class Meta:
         managed = False
-        app_label = "canvas_sdk"
         db_table = "canvas_sdk_data_api_taskcomment_001"
 
     id = models.UUIDField()
@@ -78,7 +74,7 @@ class TaskComment(models.Model):
     created = models.DateTimeField()
     modified = models.DateTimeField()
     creator = models.ForeignKey(
-        Staff, on_delete=models.DO_NOTHING, related_name="comments", null=True
+        "v1.Staff", on_delete=models.DO_NOTHING, related_name="comments", null=True
     )
     task = models.ForeignKey(Task, on_delete=models.DO_NOTHING, related_name="comments", null=True)
     body = models.TextField()
@@ -89,7 +85,6 @@ class TaskLabel(models.Model):
 
     class Meta:
         managed = False
-        app_label = "canvas_sdk"
         db_table = "canvas_sdk_data_api_tasklabel_001"
 
     id = models.UUIDField()
@@ -108,7 +103,6 @@ class TaskTaskLabel(models.Model):
 
     class Meta:
         managed = False
-        app_label = "canvas_sdk"
         db_table = "canvas_sdk_data_api_tasktasklabel_001"
 
     dbid = models.BigIntegerField(primary_key=True)

canvas_sdk/v1/data/user.py

@@ -6,7 +6,6 @@ class CanvasUser(models.Model):
 
     class Meta:
         managed = False
-        app_label = "canvas_sdk"
         db_table = "canvas_sdk_data_api_auth_user_001"
 
     dbid = models.BigIntegerField(db_column="dbid", primary_key=True)

canvas_sdk/v1/models.py

@@ -0,0 +1,4 @@
+# Normally we would register Django models in the models module, but they are in "data" for legacy
+# reasons. For this reason, we import * from data to avoid duplication.
+
+from .data import *  # noqa: F403

plugin_runner/aws_headers.py

@@ -0,0 +1,77 @@
+# Shamelessly cribbed from https://charemza.name/blog/posts/aws/python/you-might-not-need-boto-3/
+
+import datetime
+import hashlib
+import hmac
+import urllib.parse
+
+
+def aws_sig_v4_headers(
+    access_key_id: str,
+    secret_access_key: str,
+    pre_auth_headers: dict[str, str],
+    service: str,
+    region: str,
+    host: str,
+    method: str,
+    path: str,
+    query: dict[str, str],
+    payload: bytes,
+) -> dict[str, str]:
+    """Constructs signed headers for use in requests made to AWS."""
+    algorithm = "AWS4-HMAC-SHA256"
+    now = datetime.datetime.utcnow()
+    amzdate = now.strftime("%Y%m%dT%H%M%SZ")
+    datestamp = now.strftime("%Y%m%d")
+    payload_hash = hashlib.sha256(payload).hexdigest()
+    credential_scope = f"{datestamp}/{region}/{service}/aws4_request"
+
+    pre_auth_headers_lower = {
+        header_key.lower(): " ".join(header_value.split())
+        for header_key, header_value in pre_auth_headers.items()
+    }
+    required_headers = {
+        "host": host,
+        "x-amz-content-sha256": payload_hash,
+        "x-amz-date": amzdate,
+    }
+    headers = {**pre_auth_headers_lower, **required_headers}
+    header_keys = sorted(headers.keys())
+    signed_headers = ";".join(header_keys)
+
+    def signature() -> str:
+        def canonical_request() -> str:
+            canonical_uri = urllib.parse.quote(path, safe="/~")
+            quoted_query = sorted(
+                (urllib.parse.quote(key, safe="~"), urllib.parse.quote(value, safe="~"))
+                for key, value in query.items()
+            )
+            canonical_querystring = "&".join(f"{key}={value}" for key, value in quoted_query)
+            canonical_headers = "".join(f"{key}:{headers[key]}\n" for key in header_keys)
+
+            return (
+                f"{method}\n{canonical_uri}\n{canonical_querystring}\n"
+                + f"{canonical_headers}\n{signed_headers}\n{payload_hash}"
+            )
+
+        def sign(key: bytes, msg: str) -> bytes:
+            return hmac.new(key, msg.encode("utf-8"), hashlib.sha256).digest()
+
+        string_to_sign = (
+            f"{algorithm}\n{amzdate}\n{credential_scope}\n"
+            + hashlib.sha256(canonical_request().encode("utf-8")).hexdigest()
+        )
+
+        date_key = sign(("AWS4" + secret_access_key).encode("utf-8"), datestamp)
+        region_key = sign(date_key, region)
+        service_key = sign(region_key, service)
+        request_key = sign(service_key, "aws4_request")
+        return sign(request_key, string_to_sign).hex()
+
+    return {
+        **pre_auth_headers,
+        "x-amz-date": amzdate,
+        "x-amz-content-sha256": payload_hash,
+        "Authorization": f"{algorithm} Credential={access_key_id}/{credential_scope}, "
+        f"SignedHeaders={signed_headers}, Signature=" + signature(),
+    }

plugin_runner/plugin_installer.py

@@ -9,12 +9,13 @@ from pathlib import Path
 from typing import Any, TypedDict
 from urllib import parse
 
-import boto3
 import psycopg
+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
 
 # Plugin "packages" include this prefix in the database record for the plugin and the S3 bucket key.
@@ -96,19 +97,36 @@ def _extract_rows_to_dict(rows: list) -> dict[str, PluginAttributes]:
 
 
 @contextmanager
-def download_plugin(plugin_package: str) -> Generator:
+def download_plugin(plugin_package: str) -> Generator[Path, None, None]:
     """Download the plugin package from the S3 bucket."""
-    s3 = boto3.client("s3")
+    method = "GET"
+    host = f"s3-{settings.AWS_REGION}.amazonaws.com"
+    bucket = settings.MEDIA_S3_BUCKET_NAME
+    customer_identifier = settings.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,
+        pre_auth_headers,
+        "s3",
+        settings.AWS_REGION,
+        host,
+        method,
+        path,
+        query,
+        payload,
+    )
+
     with tempfile.TemporaryDirectory() as temp_dir:
         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:
-            s3.download_fileobj(
-                "canvas-client-media",
-                f"{settings.CUSTOMER_IDENTIFIER}/{plugin_package}",
-                download_file,
-            )
+            response = requests.request(method=method, url=f"https://{host}{path}", headers=headers)
+            download_file.write(response.content)
         yield download_path
 
 

plugin_runner/plugin_runner.py

@@ -261,32 +261,15 @@ def find_modules(base_path: pathlib.Path, prefix: str | None = None) -> list[str
     return modules
 
 
-def sandbox_from_package(package_path: pathlib.Path) -> dict[str, Any]:
+def sandbox_from_module(base_path: pathlib.Path, module_name: 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."""
-    module_path = package_path / str(module_name.replace(".", "/") + ".py")
+    module_path = base_path / str(module_name.replace(".", "/") + ".py")
 
     if not module_path.exists():
         raise ModuleNotFoundError(f'Could not load module "{module_name}"')
 
-    source_code = module_path.read_text()
+    sandbox = Sandbox(module_path, namespace=module_name)
 
-    full_module_name = f"{package_path.name}.{module_name}"
-
-    sandbox = Sandbox(source_code, namespace=full_module_name)
     return sandbox.execute()
 
 
@@ -320,7 +303,6 @@ def load_or_reload_plugin(path: pathlib.Path) -> None:
         handlers = manifest_json["components"].get("protocols", []) + manifest_json[
             "components"
         ].get("applications", [])
-        results = sandbox_from_package(path)
     except Exception as e:
         log.error(f'Unable to load plugin "{name}": {str(e)}')
         return
@@ -336,11 +318,11 @@ def load_or_reload_plugin(path: pathlib.Path) -> None:
             continue
 
         try:
+            result = sandbox_from_module(path.parent, handler_module)
+
             if name_and_class in LOADED_PLUGINS:
                 log.info(f"Reloading plugin '{name_and_class}'")
 
-                result = results[handler_module]
-
                 LOADED_PLUGINS[name_and_class]["active"] = True
 
                 LOADED_PLUGINS[name_and_class]["class"] = result[handler_class]
@@ -349,8 +331,6 @@ def load_or_reload_plugin(path: pathlib.Path) -> None:
             else:
                 log.info(f"Loading plugin '{name_and_class}'")
 
-                result = results[handler_module]
-
                 LOADED_PLUGINS[name_and_class] = {
                     "active": True,
                     "class": result[handler_class],

plugin_runner/sandbox.py

@@ -1,7 +1,10 @@
 import ast
 import builtins
+import importlib
+import sys
 from _ast import AnnAssign
 from functools import cached_property
+from pathlib import Path
 from typing import Any, cast
 
 from RestrictedPython import (
@@ -31,6 +34,7 @@ from RestrictedPython.transformer import (
 #
 ALLOWED_MODULES = frozenset(
     [
+        "__future__",
         "_strptime",
         "arrow",
         "base64",
@@ -46,8 +50,10 @@ ALLOWED_MODULES = frozenset(
         "canvas_sdk.value_set",
         "canvas_sdk.views",
         "contextlib",
+        "dataclasses",
         "datetime",
         "dateutil",
+        "decimal",
         "django.db.models",
         "django.utils.functional",
         "enum",
@@ -60,6 +66,7 @@ ALLOWED_MODULES = frozenset(
         "math",
         "operator",
         "pickletools",
+        "pydantic",
         "random",
         "rapidfuzz",
         "re",
@@ -88,6 +95,20 @@ def _apply(_ob: Any, *args: Any, **kwargs: Any) -> Any:
     return _ob(*args, **kwargs)
 
 
+def _find_folder_in_path(file_path: Path, target_folder_name: str) -> Path | None:
+    """Recursively search for a folder with the specified name in the hierarchy of the given file path."""
+    file_path = file_path.resolve()
+
+    if file_path.name == target_folder_name:
+        return file_path
+
+    # If we've reached the root of the file system, return None
+    if file_path.parent == file_path:
+        return None
+
+    return _find_folder_in_path(file_path.parent, target_folder_name)
+
+
 class Sandbox:
     """A restricted sandbox for safely executing arbitrary Python code."""
 
@@ -119,7 +140,10 @@ class Sandbox:
             return self.node_contents_visit(node)
 
         def check_name(
-            self, node: ast.ImportFrom, name: str | None, allow_magic_methods: bool = False
+            self,
+            node: ast.ImportFrom,
+            name: str | None,
+            allow_magic_methods: bool = False,
         ) -> None:
             """Check names if they are allowed.
 
@@ -199,16 +223,28 @@ 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 | Path,
+        namespace: str | None = None,
+        evaluated_modules: dict[str, bool] | None = None,
+    ) -> None:
         if source_code is None:
             raise TypeError("source_code may not be None")
-        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.namespace.split(".")[0] if self.namespace else None
+        self.namespace = namespace or "protocols"
+        self.package_name = self.namespace.split(".")[0]
+
+        if isinstance(source_code, Path):
+            if not source_code.exists():
+                raise FileNotFoundError(f"File not found: {source_code}")
+            self.source_code = source_code.read_text()
+            package_path = _find_folder_in_path(source_code, self.package_name)
+            self.base_path = package_path.parent if package_path else None
+            self._evaluated_modules: dict[str, bool] = evaluated_modules or {}
+        else:
+            self.source_code = source_code
+            self.base_path = None
 
     @cached_property
     def scope(self) -> dict[str, Any]:
@@ -266,12 +302,72 @@ class Sandbox:
     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)
+            or (self.package_name and name.split(".")[0] == self.package_name and self.base_path)
         )
 
+    def _get_module(self, module_name: str) -> Path:
+        """Get the module path for the given module name."""
+        module_relative_path = module_name.replace(".", "/")
+        module = Path(cast(Path, self.base_path) / f"{module_relative_path}.py")
+
+        if not module.exists():
+            module = Path(cast(Path, self.base_path) / f"{module_relative_path}/__init__.py")
+
+        return module
+
+    def _evaluate_module(self, module_name: str) -> None:
+        """Evaluate the given module in the sandbox.
+        If the module to import belongs to the same package as the current module, evaluate it inside a sandbox.
+        """
+        if not module_name.startswith(self.package_name) or module_name in self._evaluated_modules:
+            return  # Skip modules outside the package or already evaluated.
+
+        module = self._get_module(module_name)
+        self._evaluate_implicit_imports(module)
+
+        # Re-check after evaluating implicit imports to avoid duplicate evaluations.
+        if module_name not in self._evaluated_modules:
+            Sandbox(
+                module, namespace=module_name, evaluated_modules=self._evaluated_modules
+            ).execute()
+            self._evaluated_modules[module_name] = True
+
+        # Reload the module if already imported to ensure the latest version is used.
+        if sys.modules.get(module_name):
+            importlib.reload(sys.modules[module_name])
+
+    def _evaluate_implicit_imports(self, module: Path) -> None:
+        """Evaluate implicit imports in the sandbox."""
+        # Determine the parent module to check for implicit imports.
+        parent = module.parent.parent if module.name == "__init__.py" else module.parent
+        base_path = cast(Path, self.base_path)
+
+        # Skip evaluation if the parent module is outside the base path or already the source code root.
+        if not parent.is_relative_to(base_path) or parent == base_path:
+            return
+
+        module_name = parent.relative_to(base_path).as_posix().replace("/", ".")
+        init_file = parent / "__init__.py"
+
+        if module_name not in self._evaluated_modules:
+            if init_file.exists():
+                # Mark as evaluated to prevent infinite recursion.
+                self._evaluated_modules[module_name] = True
+                Sandbox(
+                    init_file, namespace=module_name, evaluated_modules=self._evaluated_modules
+                ).execute()
+            else:
+                # Mark as evaluated even if no init file exists to prevent redundant checks.
+                self._evaluated_modules[module_name] = True
+
+        self._evaluate_implicit_imports(parent)
+
     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.")
+
+        self._evaluate_module(name)
+
         return __import__(name, *args, **kwargs)
 
     def execute(self) -> dict:

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

@@ -0,0 +1,38 @@
+{
+    "sdk_version": "0.1.4",
+    "plugin_version": "0.0.1",
+    "name": "test_implicit_imports_plugin",
+    "description": "Edit the description in CANVAS_MANIFEST.json",
+    "components": {
+        "protocols": [
+            {
+                "class": "test_implicit_imports_plugin.protocols.my_protocol:Forbidden",
+                "description": "A protocol that does xyz...",
+                "data_access": {
+                    "event": "",
+                    "read": [],
+                    "write": []
+                }
+            },
+            {
+                "class": "test_implicit_imports_plugin.protocols.my_protocol:Allowed",
+                "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_implicit_imports_plugin/README.md

@@ -0,0 +1,11 @@
+test_forbiden_implicit_imports_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.