canvas 0.4.0__py3-none-any.whl → 0.6.0__py3-none-any.whl

canvas_sdk/effects/banner_alert/tests.py

@@ -178,12 +178,28 @@ def test_protocol_that_adds_banner_alert(
                 "placement": [AddBannerAlert.Placement.APPOINTMENT_CARD],
                 "intent": AddBannerAlert.Intent.INFO,
             },
-            '{"patient": "uuid", "key": "test-key", "data": {"narrative": "hellooo", "placement": ["appointment_card"], "intent": "info", "href": null}}',
+            '{"patient": "uuid", "patient_filter": null, "key": "test-key", "data": {"narrative": "hellooo", "placement": ["appointment_card"], "intent": "info", "href": null}}',
+        ),
+        (
+            AddBannerAlert,
+            {
+                "patient_filter": {"active": True},
+                "key": "test-key",
+                "narrative": "hellooo",
+                "placement": [AddBannerAlert.Placement.APPOINTMENT_CARD],
+                "intent": AddBannerAlert.Intent.INFO,
+            },
+            '{"patient": null, "patient_filter": {"active": true}, "key": "test-key", "data": {"narrative": "hellooo", "placement": ["appointment_card"], "intent": "info", "href": null}}',
         ),
         (
             RemoveBannerAlert,
             {"patient_id": "uuid", "key": "testeroo"},
-            '{"patient": "uuid", "key": "testeroo"}',
+            '{"patient": "uuid", "patient_filter": null, "key": "testeroo"}',
+        ),
+        (
+            RemoveBannerAlert,
+            {"patient_filter": {"active": True}, "key": "testeroo"},
+            '{"patient": null, "patient_filter": {"active": true}, "key": "testeroo"}',
         ),
     ],
 )
@@ -204,7 +220,7 @@ def test_banner_alert_apply_method_succeeds_with_all_required_fields(
             AddBannerAlert,
             [
                 "5 validation errors for AddBannerAlert",
-                "Field 'patient_id' is required to apply an AddBannerAlert [type=missing",
+                "Field 'patient_id' or 'patient_filter' is required to apply an AddBannerAlert [type=missing",
                 "Field 'key' is required to apply an AddBannerAlert [type=missing",
                 "Field 'narrative' is required to apply an AddBannerAlert [type=missing",
                 "Field 'placement' is required to apply an AddBannerAlert [type=missing",
@@ -215,7 +231,7 @@ def test_banner_alert_apply_method_succeeds_with_all_required_fields(
             RemoveBannerAlert,
             [
                 "2 validation errors for RemoveBannerAlert",
-                "Field 'patient_id' is required to apply a RemoveBannerAlert [type=missing",
+                "Field 'patient_id' or 'patient_filter' is required to apply a RemoveBannerAlert [type=missing",
                 "Field 'key' is required to apply a RemoveBannerAlert [type=missing",
             ],
         ),

canvas_sdk/effects/base.py

@@ -10,6 +10,8 @@ class _BaseEffect(Model):
     A Canvas Effect that changes user behavior or autonomously performs activities on behalf of users.
     """
 
+    patient_filter: dict | None = None
+
     class Meta:
         effect_type = EffectType.UNKNOWN_EFFECT
 

canvas_sdk/effects/patient_chart_summary_configuration.py

@@ -25,6 +25,7 @@ class PatientChartSummaryConfiguration(_BaseEffect):
         IMMUNIZATIONS = "immunizations"
         SURGICAL_HISTORY = "surgical_history"
         FAMILY_HISTORY = "family_history"
+        CODING_GAPS = "coding_gaps"
 
     sections: list[Section] = Field(min_length=1)
 

canvas_sdk/effects/protocol_card/protocol_card.py

@@ -42,7 +42,7 @@ class ProtocolCard(_BaseEffect):
 
     class Meta:
         effect_type = EffectType.ADD_OR_UPDATE_PROTOCOL_CARD
-        apply_required_fields = ("patient_id", "key")
+        apply_required_fields = ("patient_id|patient_filter", "key")
 
     patient_id: str | None = None
     key: str | None = None
@@ -68,7 +68,12 @@ class ProtocolCard(_BaseEffect):
     @property
     def effect_payload(self) -> dict[str, Any]:
         """The payload of the effect."""
-        return {"patient": self.patient_id, "key": self.key, "data": self.values}
+        return {
+            "patient": self.patient_id,
+            "patient_filter": self.patient_filter,
+            "key": self.key,
+            "data": self.values,
+        }
 
     def add_recommendation(
         self,

canvas_sdk/effects/protocol_card/tests.py

@@ -25,7 +25,7 @@ def test_apply_method_succeeds_with_patient_id_and_key() -> None:
     applied = p.apply()
     assert (
         applied.payload
-        == '{"patient": "uuid", "key": "something-unique", "data": {"title": "", "narrative": "", "recommendations": [], "status": "due", "feedback_enabled": false}}'
+        == '{"patient": "uuid", "patient_filter": null, "key": "something-unique", "data": {"title": "", "narrative": "", "recommendations": [], "status": "due", "feedback_enabled": false}}'
     )
 
 
@@ -38,7 +38,7 @@ def test_apply_method_raises_error_without_patient_id_and_key() -> None:
 
     assert "2 validation errors for ProtocolCard" in err_msg
     assert (
-        "Field 'patient_id' is required to apply a ProtocolCard [type=missing, input_value=None, input_type=NoneType]"
+        "Field 'patient_id' or 'patient_filter' is required to apply a ProtocolCard [type=missing, input_value=None, input_type=NoneType]"
         in err_msg
     )
     assert (

canvas_sdk/v1/data/base.py

@@ -1,5 +1,5 @@
 from collections.abc import Container
-from typing import TYPE_CHECKING, Type, cast
+from typing import TYPE_CHECKING, Self, Type, cast
 
 from django.db import models
 from django.db.models import Q
@@ -11,25 +11,28 @@ if TYPE_CHECKING:
 class CommittableModelManager(models.Manager):
     """A manager for commands that can be committed."""
 
-    def get_queryset(self) -> "models.QuerySet":
+    def get_queryset(self) -> "CommittableQuerySet":
         """Return a queryset that filters out deleted objects."""
         # TODO: Should we just filter these out at the view level?
-        return super().get_queryset().filter(deleted=False)
+        return CommittableQuerySet(self.model, using=self._db).filter(deleted=False)
 
-    def committed(self) -> "models.QuerySet":
+
+class CommittableQuerySet(models.QuerySet):
+    """A queryset for committable objects."""
+
+    def committed(self) -> "Self":
         """Return a queryset that filters for objects that have been committed."""
-        # The committer_id IS set, and the entered_in_error_id IS NOT set
         return self.filter(committer_id__isnull=False, entered_in_error_id__isnull=True)
 
-    def for_patient(self, patient_id: str) -> "models.QuerySet":
+    def for_patient(self, patient_id: str) -> "Self":
         """Return a queryset that filters objects for a specific patient."""
         return self.filter(patient__id=patient_id)
 
 
-class ValueSetLookupQuerySet(models.QuerySet):
+class ValueSetLookupQuerySet(CommittableQuerySet):
     """A QuerySet that can filter objects based on a ValueSet."""
 
-    def find(self, value_set: Type["ValueSet"]) -> models.QuerySet:
+    def find(self, value_set: Type["ValueSet"]) -> "Self":
         """
         Filters conditions, medications, etc. to those found in the inherited ValueSet class that is passed.
 

canvas_sdk/v1/data/condition.py

@@ -1,6 +1,10 @@
 from django.db import models
 
-from canvas_sdk.v1.data.base import CommittableModelManager, ValueSetLookupQuerySet
+from canvas_sdk.v1.data.base import (
+    CommittableModelManager,
+    CommittableQuerySet,
+    ValueSetLookupQuerySet,
+)
 from canvas_sdk.v1.data.patient import Patient
 from canvas_sdk.v1.data.user import CanvasUser
 
@@ -19,7 +23,7 @@ class Condition(models.Model):
         app_label = "canvas_sdk"
         db_table = "canvas_sdk_data_api_condition_001"
 
-    objects = CommittableModelManager.from_queryset(ConditionQuerySet)()
+    objects = ConditionQuerySet.as_manager()
 
     id = models.UUIDField()
     dbid = models.BigIntegerField(primary_key=True)

canvas_sdk/v1/data/detected_issue.py

@@ -0,0 +1,52 @@
+from django.db import models
+
+from canvas_sdk.v1.data import Patient
+from canvas_sdk.v1.data.user import CanvasUser
+
+
+class DetectedIssue(models.Model):
+    """DetectedIssue."""
+
+    class Meta:
+        managed = False
+        app_label = "canvas_sdk"
+        db_table = "canvas_sdk_data_api_detectedissue_001"
+
+    id = models.UUIDField()
+    dbid = models.BigIntegerField(primary_key=True)
+    created = models.DateTimeField()
+    modified = models.DateTimeField()
+    identified = models.DateTimeField()
+    deleted = models.BooleanField()
+    originator = models.ForeignKey(CanvasUser, on_delete=models.DO_NOTHING)
+    committer = models.ForeignKey(CanvasUser, on_delete=models.DO_NOTHING)
+    entered_in_error = models.ForeignKey(CanvasUser, on_delete=models.DO_NOTHING)
+    patient = models.ForeignKey(
+        Patient, on_delete=models.DO_NOTHING, related_name="detected_issues"
+    )
+    code = models.CharField()
+    status = models.CharField()
+    severity = models.CharField()
+    reference = models.CharField()
+    issue_identifier = models.CharField()
+    issue_identifier_system = models.CharField()
+    detail = models.TextField()
+
+
+class DetectedIssueEvidence(models.Model):
+    """DetectedIssueEvidence."""
+
+    class Meta:
+        managed = False
+        app_label = "canvas_sdk"
+        db_table = "canvas_sdk_data_api_detectedissueevidence_001"
+
+    dbid = models.BigIntegerField(primary_key=True)
+    system = models.CharField()
+    version = models.CharField()
+    code = models.CharField()
+    display = models.CharField()
+    user_selected = models.BooleanField()
+    detected_issue = models.ForeignKey(
+        DetectedIssue, on_delete=models.DO_NOTHING, related_name="evidence"
+    )

canvas_sdk/v1/data/patient.py

@@ -1,4 +1,4 @@
-from typing import Self
+from typing import TYPE_CHECKING, Self
 
 from django.db import models
 

canvas_sdk/v1/data/protocol_override.py

@@ -0,0 +1,58 @@
+from django.db import models
+
+from canvas_sdk.v1.data.base import CommittableModelManager
+from canvas_sdk.v1.data.patient import Patient
+from canvas_sdk.v1.data.user import CanvasUser
+
+
+class IntervalUnit(models.TextChoices):
+    """ProtocolOverride cycle IntervalUnit."""
+
+    DAYS = "days", "days"
+    MONTHS = "months", "months"
+    YEARS = "years", "years"
+
+
+class Status(models.TextChoices):
+    """ProtocolOverride Status."""
+
+    ACTIVE = "active", "active"
+    INACTIVE = "inactive", "inactive"
+
+
+class ProtocolOverride(models.Model):
+    """ProtocolOverride."""
+
+    class Meta:
+        managed = False
+        app_label = "canvas_sdk"
+        db_table = "canvas_sdk_data_api_protocoloverride_001"
+
+    objects = CommittableModelManager()
+
+    id = models.UUIDField()
+    dbid = models.BigIntegerField(primary_key=True)
+    created = models.DateTimeField()
+    modified = models.DateTimeField()
+    deleted = models.BooleanField()
+    committer = models.ForeignKey(CanvasUser, on_delete=models.DO_NOTHING)
+    entered_in_error = models.ForeignKey(CanvasUser, on_delete=models.DO_NOTHING)
+    patient = models.ForeignKey(
+        Patient,
+        on_delete=models.DO_NOTHING,
+        related_name="protocol_overrides",
+    )
+    protocol_key = models.CharField()
+    is_adjustment = models.BooleanField()
+    reference_date = models.DateTimeField()
+    cycle_in_days = models.IntegerField()
+    is_snooze = models.BooleanField()
+    snooze_date = models.DateField()
+    snoozed_days = models.IntegerField()
+    # reason_id = models.BigIntegerField()
+    snooze_comment = models.TextField()
+    narrative = models.CharField()
+    # note_id = models.BigIntegerField()
+    cycle_quantity = models.IntegerField()
+    cycle_unit = models.CharField(choices=IntervalUnit.choices)
+    status = models.CharField(choices=Status.choices)

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, AsyncGenerator, Optional, TypedDict, cast
+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,7 @@ 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):
@@ -113,7 +103,7 @@ class PluginRunner(PluginRunnerServicer):
         event_start_time = time.time()
         event_type = request.type
         event_name = EventType.Name(event_type)
-        relevant_plugins = EVENT_PROTOCOL_MAP.get(event_name, [])
+        relevant_plugins = EVENT_PROTOCOL_MAP[event_name]
 
         if event_type in [EventType.PLUGIN_CREATED, EventType.PLUGIN_UPDATED]:
             plugin_name = request.target
@@ -197,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()
 
 
@@ -240,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
@@ -258,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
 
@@ -268,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,
@@ -285,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"):

plugin_runner/sandbox.py

@@ -59,6 +59,7 @@ ALLOWED_MODULES = frozenset(
         "operator",
         "pickletools",
         "random",
+        "rapidfuzz",
         "re",
         "requests",
         "string",
@@ -75,12 +76,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 +91,7 @@ class Sandbox:
 
     source_code: str
     namespace: str
+    module_name: str | None
 
     class Transformer(RestrictingNodeTransformer):
         """A node transformer for customizing the sandbox compiler."""
@@ -204,12 +200,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 +221,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 +267,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"
+}