canvas 0.1.15__py3-none-any.whl → 0.2.10__py3-none-any.whl

canvas_sdk/effects/banner_alert/tests.py

@@ -0,0 +1,224 @@
+import shutil
+from contextlib import chdir
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Generator
+
+import pytest
+import requests
+from pydantic import ValidationError
+from typer.testing import CliRunner
+
+import settings
+from canvas_cli.apps.plugin.plugin import _build_package, plugin_url
+from canvas_cli.main import app
+from canvas_sdk.commands.tests.test_utils import MaskedValue
+from canvas_sdk.effects.banner_alert import AddBannerAlert, RemoveBannerAlert
+
+runner = CliRunner()
+
+
+@pytest.fixture(scope="session")
+def token() -> MaskedValue:
+    return MaskedValue(
+        requests.post(
+            f"{settings.INTEGRATION_TEST_URL}/auth/token/",
+            headers={"Content-Type": "application/x-www-form-urlencoded"},
+            data={
+                "grant_type": "client_credentials",
+                "client_id": settings.INTEGRATION_TEST_CLIENT_ID,
+                "client_secret": settings.INTEGRATION_TEST_CLIENT_SECRET,
+            },
+        ).json()["access_token"]
+    )
+
+
+@pytest.fixture(scope="session")
+def first_patient_id(token: MaskedValue) -> dict:
+    headers = {
+        "Authorization": f"Bearer {token.value}",
+        "Content-Type": "application/json",
+        "Accept": "application/json",
+    }
+    patients = requests.get(f"{settings.INTEGRATION_TEST_URL}/api/Patient", headers=headers).json()
+    return patients["entry"][0]["resource"]["key"]
+
+
+@pytest.fixture(scope="session")
+def plugin_name() -> str:
+    return f"addbanneralert{datetime.now().timestamp()}".replace(".", "")
+
+
+@pytest.fixture(autouse=True, scope="session")
+def write_and_install_protocol_and_clean_up(
+    first_patient_id: str, plugin_name: str, token: MaskedValue
+) -> Generator[Any, Any, Any]:
+    # write the protocol
+    with chdir(Path("./custom-plugins")):
+        runner.invoke(app, "init", input=plugin_name)
+
+    protocol = open(f"./custom-plugins/{plugin_name}/protocols/my_protocol.py", "w")
+    protocol.write(
+        f"""from canvas_sdk.effects.banner_alert import AddBannerAlert
+from canvas_sdk.events import EventType
+from canvas_sdk.protocols import BaseProtocol
+
+class Protocol(BaseProtocol):
+    RESPONDS_TO = EventType.Name(EventType.ENCOUNTER_CREATED)
+    def compute(self):
+        return [
+            AddBannerAlert(
+                patient_id="{first_patient_id}",
+                key="{plugin_name}",
+                narrative="this is a test",
+                placement=[AddBannerAlert.Placement.CHART],
+                intent=AddBannerAlert.Intent.INFO,
+            ).apply()
+        ]
+"""
+    )
+    protocol.close()
+
+    # install the plugin
+    requests.post(
+        plugin_url(settings.INTEGRATION_TEST_URL),
+        data={"is_enabled": True},
+        files={"package": open(_build_package(Path(f"./custom-plugins/{plugin_name}")), "rb")},
+        headers={"Authorization": f"Bearer {token.value}"},
+    )
+
+    yield
+
+    # clean up
+    if Path(f"./custom-plugins/{plugin_name}").exists():
+        shutil.rmtree(Path(f"./custom-plugins/{plugin_name}"))
+
+    # disable
+    requests.patch(
+        plugin_url(settings.INTEGRATION_TEST_URL, plugin_name),
+        data={"is_enabled": False},
+        headers={
+            "Authorization": f"Bearer {token.value}",
+        },
+    )
+    # delete
+    requests.delete(
+        plugin_url(settings.INTEGRATION_TEST_URL, plugin_name),
+        headers={"Authorization": f"Bearer {token.value}"},
+    )
+
+    # confirm no more banner
+    patient_banners_none = requests.get(
+        f"{settings.INTEGRATION_TEST_URL}/api/BannerAlert/?patient__key={first_patient_id}",
+        headers={
+            "Authorization": f"Bearer {token.value}",
+        },
+    ).json()
+    patient_banner = next(
+        (b for b in patient_banners_none["results"] if b["key"] == plugin_name), None
+    )
+    assert patient_banner is None
+
+
+@pytest.mark.integtest
+def test_protocol_that_adds_banner_alert(
+    token: MaskedValue, plugin_name: str, first_patient_id: str
+) -> None:
+    # trigger the event
+    requests.post(
+        f"{settings.INTEGRATION_TEST_URL}/api/Note/",
+        headers={
+            "Authorization": f"Bearer {token.value}",
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+        },
+        json={
+            "patient": 1,
+            "provider": 1,
+            "note_type": "office",
+            "note_type_version": 1,
+            "lastModifiedBySessionKey": "8fee3c03a525cebee1d8a6b8e63dd4dg",
+        },
+    )
+
+    patient_banners = requests.get(
+        f"{settings.INTEGRATION_TEST_URL}/api/BannerAlert/?patient__key={first_patient_id}",
+        headers={
+            "Authorization": f"Bearer {token.value}",
+        },
+    ).json()
+    assert patient_banners["count"] > 0
+
+    patient_banner = next(b for b in patient_banners["results"] if b["key"] == plugin_name)
+    assert patient_banner["pluginName"] == plugin_name
+    assert patient_banner["narrative"] == "this is a test"
+    assert patient_banner["placement"] == ["chart"]
+    assert patient_banner["intent"] == "info"
+    assert patient_banner["href"] is None
+    assert patient_banner["status"] == "active"
+
+
+@pytest.mark.parametrize(
+    "Effect,params,expected_payload",
+    [
+        (
+            AddBannerAlert,
+            {
+                "patient_id": "uuid",
+                "key": "test-key",
+                "narrative": "hellooo",
+                "placement": [AddBannerAlert.Placement.APPOINTMENT_CARD],
+                "intent": AddBannerAlert.Intent.INFO,
+            },
+            '{"patient": "uuid", "key": "test-key", "data": {"narrative": "hellooo", "placement": ["appointment_card"], "intent": "info", "href": null}}',
+        ),
+        (
+            RemoveBannerAlert,
+            {"patient_id": "uuid", "key": "testeroo"},
+            '{"patient": "uuid", "key": "testeroo"}',
+        ),
+    ],
+)
+def test_banner_alert_apply_method_succeeds_with_all_required_fields(
+    Effect: AddBannerAlert | RemoveBannerAlert, params: dict, expected_payload: str
+) -> None:
+    b = Effect()
+    for k, v in params.items():
+        setattr(b, k, v)
+    applied = b.apply()
+    assert applied.payload == expected_payload
+
+
+@pytest.mark.parametrize(
+    "Effect,expected_err_msgs",
+    [
+        (
+            AddBannerAlert,
+            [
+                "5 validation errors for AddBannerAlert",
+                "Field 'patient_id' 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",
+                "Field 'intent' is required to apply an AddBannerAlert [type=missing",
+            ],
+        ),
+        (
+            RemoveBannerAlert,
+            [
+                "2 validation errors for RemoveBannerAlert",
+                "Field 'patient_id' is required to apply a RemoveBannerAlert [type=missing",
+                "Field 'key' is required to apply a RemoveBannerAlert [type=missing",
+            ],
+        ),
+    ],
+)
+def test_banner_alert_apply_method_raises_error_without_required_fields(
+    Effect: AddBannerAlert | RemoveBannerAlert, expected_err_msgs: str
+) -> None:
+    b = Effect()
+    with pytest.raises(ValidationError) as e:
+        b.apply()
+    err_msg = repr(e.value)
+    for expected in expected_err_msgs:
+        assert expected in err_msg

canvas_sdk/effects/base.py

@@ -1,12 +1,11 @@
 import json
 from typing import Any
 
-from pydantic import BaseModel, ConfigDict
-
+from canvas_sdk.base import Model
 from canvas_sdk.effects import Effect, EffectType
 
 
-class _BaseEffect(BaseModel):
+class _BaseEffect(Model):
     """
     A Canvas Effect that changes user behavior or autonomously performs activities on behalf of users.
     """
@@ -14,8 +13,6 @@ class _BaseEffect(BaseModel):
     class Meta:
         effect_type = EffectType.UNKNOWN_EFFECT
 
-    model_config = ConfigDict(strict=True, validate_assignment=True)
-
     @property
     def values(self) -> dict[str, Any]:
         return {}
@@ -25,4 +22,5 @@ class _BaseEffect(BaseModel):
         return {"data": self.values}
 
     def apply(self) -> Effect:
+        self._validate_before_effect("apply")
         return Effect(type=self.Meta.effect_type, payload=json.dumps(self.effect_payload))

canvas_sdk/effects/patient_chart_summary_configuration.py

@@ -0,0 +1,39 @@
+from enum import Enum
+from typing import Any
+
+from pydantic import Field
+
+from canvas_sdk.effects.base import EffectType, _BaseEffect
+
+
+class PatientChartSummaryConfiguration(_BaseEffect):
+    """
+    An Effect that will decide which sections appear on the patient's chart summary in Canvas.
+    """
+
+    class Meta:
+        effect_type = EffectType.SHOW_PATIENT_CHART_SUMMARY_SECTIONS
+
+    class Section(Enum):
+        SOCIAL_DETERMINANTS = "social_determinants"
+        GOALS = "goals"
+        CONDITIONS = "conditions"
+        MEDICATIONS = "medications"
+        ALLERGIES = "allergies"
+        CARE_TEAMS = "care_teams"
+        VITALS = "vitals"
+        IMMUNIZATIONS = "immunizations"
+        SURGICAL_HISTORY = "surgical_history"
+        FAMILY_HISTORY = "family_history"
+
+    sections: list[Section] = Field(min_length=1)
+
+    @property
+    def values(self) -> dict[str, Any]:
+        """The PatientChartSummaryConfiguration's values."""
+        return {"sections": [s.value for s in self.sections]}
+
+    @property
+    def effect_payload(self) -> dict[str, Any]:
+        """The payload of the effect."""
+        return {"data": self.values}

canvas_sdk/effects/protocol_card/__init__.py

@@ -0,0 +1 @@
+from canvas_sdk.effects.protocol_card.protocol_card import ProtocolCard, Recommendation

canvas_sdk/effects/protocol_card/protocol_card.py

@@ -0,0 +1,83 @@
+from enum import Enum
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict
+
+from canvas_sdk.effects.base import EffectType, _BaseEffect
+
+
+class Recommendation(BaseModel):
+    """
+    A Recommendation for a Protocol Card.
+    """
+
+    model_config = ConfigDict(strict=True, validate_assignment=True)
+
+    title: str = ""
+    button: str = ""
+    href: str | None = None
+    command: str | None = None
+    context: dict | None = None
+
+    @property
+    def values(self) -> dict:
+        """The ProtocolCard recommendation's values."""
+        return {
+            "title": self.title,
+            "button": self.button,
+            "href": self.href,
+            "command": {"type": self.command} if self.command else {},
+            "context": self.context or {},
+        }
+
+
+class ProtocolCard(_BaseEffect):
+    """
+    An Effect that will result in a protocol card in Canvas.
+    """
+
+    class Status(Enum):
+        DUE = "due"
+        SATISFIED = "satisfied"
+
+    class Meta:
+        effect_type = EffectType.ADD_OR_UPDATE_PROTOCOL_CARD
+        apply_required_fields = ("patient_id", "key")
+
+    patient_id: str | None = None
+    key: str | None = None
+    title: str = ""
+    narrative: str = ""
+    recommendations: list[Recommendation] = []
+    status: Status = Status.DUE  # type: ignore
+
+    @property
+    def values(self) -> dict[str, Any]:
+        """The ProtocolCard's values."""
+        return {
+            "title": self.title,
+            "narrative": self.narrative,
+            "recommendations": [
+                rec.values | {"key": i} for i, rec in enumerate(self.recommendations)
+            ],
+            "status": self.status.value,
+        }
+
+    @property
+    def effect_payload(self) -> dict[str, Any]:
+        """The payload of the effect."""
+        return {"patient": self.patient_id, "key": self.key, "data": self.values}
+
+    def add_recommendation(
+        self,
+        title: str = "",
+        button: str = "",
+        href: str | None = None,
+        command: str | None = None,
+        context: dict | None = None,
+    ) -> None:
+        """Adds a recommendation to the protocol card's list of recommendations."""
+        recommendation = Recommendation(
+            title=title, button=button, href=href, command=command, context=context
+        )
+        self.recommendations.append(recommendation)

canvas_sdk/effects/protocol_card/tests.py

@@ -0,0 +1,184 @@
+import pytest
+from pydantic import ValidationError
+
+from canvas_sdk.commands import (
+    AssessCommand,
+    DiagnoseCommand,
+    GoalCommand,
+    HistoryOfPresentIllnessCommand,
+    MedicationStatementCommand,
+    PlanCommand,
+    PrescribeCommand,
+    QuestionnaireCommand,
+    ReasonForVisitCommand,
+    StopMedicationCommand,
+    UpdateGoalCommand,
+)
+from canvas_sdk.commands.base import _BaseCommand
+from canvas_sdk.effects.protocol_card import ProtocolCard, Recommendation
+
+
+def test_apply_method_succeeds_with_patient_id_and_key() -> None:
+    p = ProtocolCard(patient_id="uuid", key="something-unique")
+    applied = p.apply()
+    assert (
+        applied.payload
+        == '{"patient": "uuid", "key": "something-unique", "data": {"title": "", "narrative": "", "recommendations": [], "status": "due"}}'
+    )
+
+
+def test_apply_method_raises_error_without_patient_id_and_key() -> None:
+    p = ProtocolCard()
+
+    with pytest.raises(ValidationError) as e:
+        p.apply()
+    err_msg = repr(e.value)
+
+    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]"
+        in err_msg
+    )
+    assert (
+        "Field 'key' is required to apply a ProtocolCard [type=missing, input_value=None, input_type=NoneType]"
+        in err_msg
+    )
+
+
+@pytest.mark.parametrize(
+    "init_params,rec1_params,rec2_params",
+    [
+        (
+            {
+                "key": "link_rec",
+                "patient_id": "patientuuid",
+                "title": "This is a test!",
+                "narrative": "we should only expect a link and a button",
+            },
+            {
+                "title": "this is a link",
+                "button": "click this",
+                "href": "https://canvasmedical.com/",
+            },
+            {"title": "second link", "button": "don't click this", "href": "https://google.com/"},
+        ),
+        (
+            {
+                "key": "command_rec",
+                "patient_id": "patientuuid",
+                "title": "This is a test for command recommendations!",
+                "narrative": "we should only expect buttons to insert commands",
+            },
+            {
+                "title": "this is a command",
+                "button": "click this",
+                "command": "updategoal",
+                "context": {"progress": "none"},
+            },
+            {
+                "title": "another command",
+                "button": "hypertension",
+                "command": "diagnose",
+                "context": {"background": "stuff"},
+            },
+        ),
+        (
+            {
+                "patient_id": "patientuuid",
+                "key": "command_rec_with_coding_filter",
+                "title": "This is a test for command recommendations with coding filters!",
+                "narrative": "we should only expect buttons to insert commands",
+            },
+            {
+                "title": "hypertension",
+                "button": "diagnose",
+                "command": "diagnose",
+                "context": {"background": "hey", "icd10_code": "I10"},
+            },
+            {
+                "title": "fake medication",
+                "button": "prescribe",
+                "command": "prescribe",
+                "context": {"sig": "1pobid"},
+            },
+        ),
+    ],
+)
+def test_add_recommendations(
+    init_params: dict[str, str], rec1_params: dict[str, str], rec2_params: dict[str, str]
+) -> None:
+    p = ProtocolCard(**init_params)
+    p.add_recommendation(**rec1_params)
+    p.recommendations.append(Recommendation(**rec2_params))
+
+    assert p.values == {
+        "title": init_params["title"],
+        "narrative": init_params["narrative"],
+        "recommendations": [
+            {
+                "title": rec1_params.get("title", None),
+                "button": rec1_params.get("button", None),
+                "href": rec1_params.get("href", None),
+                "command": {"type": rec1_params["command"]} if "command" in rec1_params else {},
+                "context": rec1_params.get("context", {}),
+                "key": 0,
+            },
+            {
+                "title": rec2_params.get("title", None),
+                "button": rec2_params.get("button", None),
+                "href": rec2_params.get("href", None),
+                "command": {"type": rec2_params["command"]} if "command" in rec2_params else {},
+                "context": rec2_params.get("context", {}),
+                "key": 1,
+            },
+        ],
+        "status": "due",
+    }
+
+
+@pytest.mark.parametrize(
+    "Command,init_params",
+    [
+        (AssessCommand, {}),
+        (DiagnoseCommand, {"icd10_code": "I10"}),
+        (GoalCommand, {}),
+        (HistoryOfPresentIllnessCommand, {}),
+        (MedicationStatementCommand, {"fdb_code": "fakeroo"}),
+        (PlanCommand, {}),
+        (PrescribeCommand, {"fdb_code": "fake"}),
+        (QuestionnaireCommand, {}),
+        (ReasonForVisitCommand, {}),
+        (StopMedicationCommand, {}),
+        (UpdateGoalCommand, {}),
+    ],
+)
+def test_add_recommendations_from_commands(
+    Command: _BaseCommand, init_params: dict[str, str]
+) -> None:
+    cmd = Command(**init_params)
+    p = ProtocolCard(patient_id="uuid", key="commands")
+    p.recommendations.append(cmd.recommend())
+    p.recommendations.append(cmd.recommend(title="hello", button="click"))
+    p.add_recommendation(
+        title="yeehaw", button="click here", command=cmd.Meta.key.lower(), context=init_params
+    )
+
+    rec1, rec2, rec3 = p.values["recommendations"]
+    assert rec1["title"] == ""
+    assert rec1["button"] == cmd.constantized_key().lower().replace("_", " ")
+    assert rec1["href"] is None
+    assert rec1["context"] == cmd.values
+    assert rec1["command"]["type"] == cmd.Meta.key.lower()
+
+    assert rec2["title"] == "hello"
+    assert rec2["button"] == "click"
+    assert rec2["href"] is None
+    assert rec2["context"] == cmd.values
+    assert rec2["command"]["type"] == cmd.Meta.key.lower()
+
+    assert rec3["title"] == "yeehaw"
+    assert rec3["button"] == "click here"
+    assert rec3["href"] is None
+    assert rec3["command"]["type"] == cmd.Meta.key.lower()
+    for k, v in init_params.items():
+        assert rec3["context"][k] == v

canvas_sdk/handlers/base.py

@@ -1,4 +1,8 @@
 import json
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from canvas_generated.messages.events_pb2 import Event
 
 
 class BaseHandler:
@@ -6,11 +10,20 @@ class BaseHandler:
     The class that all handlers inherit from.
     """
 
-    def __init__(self, event, secrets=None) -> None:
+    secrets: dict[str, Any]
+    target: str
+
+    def __init__(
+        self,
+        event: "Event",
+        secrets: dict[str, Any] | None = None,
+    ) -> None:
         self.event = event
+
         try:
             self.context = json.loads(event.context)
         except ValueError:
             self.context = {}
+
         self.target = event.target
         self.secrets = secrets or {}

canvas_sdk/protocols/base.py

@@ -1,3 +1,6 @@
+from typing import Any
+
+from canvas_sdk.data.client import GQL_CLIENT
 from canvas_sdk.handlers.base import BaseHandler
 
 
@@ -5,3 +8,14 @@ class BaseProtocol(BaseHandler):
     """
     The class that protocols inherit from.
     """
+
+    def _beta_run_gql_query(self, query: str, variables: dict | None = None) -> dict[str, Any]:
+        return GQL_CLIENT.query(
+            query,
+            variables=variables,
+            extra_args={
+                "headers": {
+                    "Authorization": f'Bearer {self.secrets["graphql_jwt"]}',
+                },
+            },
+        )

canvas_sdk/protocols/clinical_quality_measure.py

@@ -0,0 +1,41 @@
+from typing import Any
+
+from canvas_sdk.protocols.base import BaseProtocol
+
+
+class ClinicalQualityMeasure(BaseProtocol):
+    """
+    The class that ClinicalQualityMeasure protocols inherit from.
+    """
+
+    class Meta:
+        title: str = ""
+        identifiers: list[str] = []
+        description: str = ""
+        information: str = ""
+        references: list[str] = []
+        types: list[str] = []
+        authors: list[str] = []
+        show_in_chart: bool = True
+        show_in_population: bool = True
+        can_be_snoozed: bool = True
+        is_abstract: bool = False
+
+    @classmethod
+    def _meta(cls) -> dict[str, Any]:
+        """
+        Meta properties of the protocol in dictionary form.
+        """
+        base_meta = {
+            k: v for k, v in ClinicalQualityMeasure.Meta.__dict__.items() if not k.startswith("__")
+        }
+        class_meta = {k: v for k, v in cls.Meta.__dict__.items() if not k.startswith("__")}
+
+        return base_meta | class_meta
+
+    @classmethod
+    def protocol_key(cls) -> str:
+        """
+        External key used to identify the protocol.
+        """
+        return cls.__name__

canvas_sdk/utils/db.py

@@ -0,0 +1,17 @@
+import os
+from typing import Any
+from urllib import parse
+
+
+def get_database_dict_from_url() -> dict[str, Any]:
+    """Retrieves the database URL for the data module connection formatted for Django settings."""
+    parsed_url = parse.urlparse(os.getenv("DATABASE_URL"))
+    db_name = parsed_url.path[1:]
+    return {
+        "ENGINE": "django.db.backends.postgresql",
+        "NAME": db_name,
+        "USER": os.getenv("CANVAS_SDK_DATABASE_ROLE"),
+        "PASSWORD": os.getenv("CANVAS_SDK_DATABASE_ROLE_PASSWORD"),
+        "HOST": parsed_url.hostname,
+        "PORT": parsed_url.port,
+    }

canvas_sdk/v1/data/__init__.py

@@ -0,0 +1,3 @@
+from .condition import Condition, ConditionCoding
+from .medication import Medication, MedicationCoding
+from .patient import Patient