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

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/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

canvas_sdk/v1/data/allergy_intolerance.py

@@ -0,0 +1,63 @@
+from django.contrib.postgres.fields import ArrayField
+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 AllergyIntolerance(models.Model):
+    """AllergyIntolerance."""
+
+    class Meta:
+        managed = False
+        app_label = "canvas_sdk"
+        db_table = "canvas_sdk_data_api_allergyintolerance_001"
+
+    objects = CommittableModelManager()
+
+    id = models.UUIDField()
+    dbid = models.BigIntegerField(primary_key=True)
+    created = models.DateTimeField()
+    modified = models.DateTimeField()
+    editors = ArrayField(models.IntegerField())
+    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="allergy_intolerances",
+    )
+    note_id = models.BigIntegerField()
+    allergy_intolerance_type = models.CharField()
+    category = models.IntegerField()
+    status = models.CharField()
+    severity = models.CharField()
+    onset_date = models.DateField()
+    onset_date_original_input = models.CharField()
+    last_occurrence = models.DateField()
+    last_occurrence_original_input = models.CharField()
+    recorded_date = models.DateTimeField()
+    narrative = models.CharField()
+
+
+class AllergyIntoleranceCoding(models.Model):
+    """AllergyIntoleranceCoding."""
+
+    class Meta:
+        managed = False
+        app_label = "canvas_sdk"
+        db_table = "canvas_sdk_data_api_allergyintolerancecoding_001"
+
+    dbid = models.BigIntegerField(primary_key=True)
+    system = models.CharField()
+    version = models.CharField()
+    code = models.CharField()
+    display = models.CharField()
+    user_selected = models.BooleanField()
+    allergy_intolerance = models.ForeignKey(
+        AllergyIntolerance,
+        on_delete=models.DO_NOTHING,
+        related_name="codings",
+    )

canvas_sdk/v1/data/base.py

@@ -0,0 +1,47 @@
+from typing import TYPE_CHECKING, Type
+
+from django.db import models
+from django.db.models import Q
+
+if TYPE_CHECKING:
+    from canvas_sdk.value_set.value_set import ValueSet
+
+
+class CommittableModelManager(models.Manager):
+    def get_queryset(self) -> "models.QuerySet":
+        # TODO: Should we just filter these out at the view level?
+        return super().get_queryset().filter(deleted=False)
+
+    def committed(self) -> "models.QuerySet":
+        # 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":
+        return self.filter(patient__id=patient_id)
+
+
+class ValueSetLookupQuerySet(models.QuerySet):
+    def find(self, value_set: Type["ValueSet"]) -> models.QuerySet:
+        """
+        Filters conditions, medications, etc. to those found in the inherited ValueSet class that is passed.
+
+        For example:
+
+        from canvas_sdk.v1.data.condition import Condition
+        from canvas_sdk.value_set.v2022.condition import MorbidObesity
+        morbid_obesity_conditions = Condition.objects.find(MorbidObesity)
+
+        This method can also be chained like so:
+
+        Condition.objects.find(MorbidObesity).find(AnaphylacticReactionToCommonBakersYeast)
+        """
+        values_dict = value_set.values
+        uri_codes = [
+            (i[1], values_dict[i[0]])
+            for i in value_set.CODE_SYSTEM_MAPPING.items()
+            if i[0] in values_dict
+        ]
+        q_filter = Q()
+        for system, codes in uri_codes:
+            q_filter |= Q(codings__system=system, codings__code__in=codes)
+        return self.filter(q_filter).distinct()

canvas_sdk/v1/data/condition.py

@@ -0,0 +1,48 @@
+from django.db import models
+
+from canvas_sdk.v1.data.base import CommittableModelManager, ValueSetLookupQuerySet
+from canvas_sdk.v1.data.patient import Patient
+from canvas_sdk.v1.data.user import CanvasUser
+
+
+class ConditionQuerySet(ValueSetLookupQuerySet):
+    """ConditionQuerySet."""
+
+    pass
+
+
+class Condition(models.Model):
+    """Condition."""
+
+    class Meta:
+        managed = False
+        app_label = "canvas_sdk"
+        db_table = "canvas_sdk_data_api_condition_001"
+
+    objects = CommittableModelManager.from_queryset(ConditionQuerySet)()
+
+    id = models.UUIDField()
+    dbid = models.BigIntegerField(primary_key=True)
+    onset_date = models.DateField()
+    resolution_date = models.DateField()
+    deleted = models.BooleanField()
+    entered_in_error = models.ForeignKey(CanvasUser, on_delete=models.DO_NOTHING)
+    committer = models.ForeignKey(CanvasUser, on_delete=models.DO_NOTHING)
+    patient = models.ForeignKey(Patient, on_delete=models.DO_NOTHING, related_name="conditions")
+
+
+class ConditionCoding(models.Model):
+    """ConditionCoding."""
+
+    class Meta:
+        managed = False
+        app_label = "canvas_sdk"
+        db_table = "canvas_sdk_data_api_conditioncoding_001"
+
+    dbid = models.BigIntegerField(primary_key=True)
+    system = models.CharField()
+    version = models.CharField()
+    code = models.CharField()
+    display = models.CharField()
+    user_selected = models.BooleanField()
+    condition = models.ForeignKey(Condition, on_delete=models.DO_NOTHING, related_name="codings")

canvas_sdk/v1/data/lab.py

@@ -0,0 +1,96 @@
+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 LabReport(models.Model):
+    class Meta:
+        managed = False
+        app_label = "canvas_sdk"
+        db_table = "canvas_sdk_data_api_labreport_001"
+
+    objects = CommittableModelManager()
+
+    id = models.UUIDField()
+    dbid = models.BigIntegerField(primary_key=True)
+    created = models.DateTimeField()
+    modified = models.DateTimeField()
+    review_mode = models.CharField()
+    junked = models.BooleanField()
+    requires_signature = models.BooleanField()
+    assigned_date = models.DateTimeField()
+    patient = models.ForeignKey(Patient, on_delete=models.DO_NOTHING, related_name="lab_reports")
+    transmission_type = models.CharField()
+    for_test_only = models.BooleanField()
+    external_id = models.CharField()
+    version = models.IntegerField()
+    requisition_number = models.CharField()
+    review = models.ForeignKey("LabReview", related_name="reports", on_delete=models.DO_NOTHING)
+    original_date = models.DateTimeField()
+    date_performed = models.DateTimeField()
+    custom_document_name = models.CharField()
+    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)
+    deleted = models.BooleanField()
+
+
+class LabReview(models.Model):
+    class Meta:
+        managed = False
+        app_label = "canvas_sdk"
+        db_table = "canvas_sdk_data_api_labreview_001"
+
+    objects = CommittableModelManager()
+
+    id = models.UUIDField()
+    dbid = models.BigIntegerField(primary_key=True)
+    created = models.DateTimeField()
+    modified = models.DateTimeField()
+    originator = models.ForeignKey(CanvasUser, on_delete=models.DO_NOTHING)
+    deleted = models.BooleanField()
+    committer = models.ForeignKey(CanvasUser, on_delete=models.DO_NOTHING)
+    entered_in_error = models.ForeignKey(CanvasUser, on_delete=models.DO_NOTHING)
+    internal_comment = models.TextField()
+    message_to_patient = models.CharField()
+    status = models.CharField()
+    patient = models.ForeignKey(Patient, on_delete=models.DO_NOTHING)
+    patient_communication_method = models.CharField()
+
+
+class LabValue(models.Model):
+    class Meta:
+        managed = False
+        app_label = "canvas_sdk"
+        db_table = "canvas_sdk_data_api_labvalue_001"
+
+    id = models.UUIDField()
+    dbid = models.BigIntegerField(primary_key=True)
+    created = models.DateTimeField()
+    modified = models.DateTimeField()
+    report = models.ForeignKey("LabReport", related_name="values", on_delete=models.DO_NOTHING)
+    value = models.TextField()
+    units = models.CharField()
+    abnormal_flag = models.CharField()
+    reference_range = models.CharField()
+    low_threshold = models.CharField()
+    high_threshold = models.CharField()
+    comment = models.TextField()
+    observation_status = models.CharField()
+
+
+class LabValueCoding(models.Model):
+    class Meta:
+        managed = False
+        app_label = "canvas_sdk"
+        db_table = "canvas_sdk_data_api_labvaluecoding_001"
+
+    dbid = models.BigIntegerField(primary_key=True)
+    created = models.DateTimeField()
+    modified = models.DateTimeField()
+    value = models.ForeignKey(LabValue, on_delete=models.DO_NOTHING, related_name="codings")
+    code = models.CharField()
+    name = models.CharField()
+    system = models.CharField()

canvas_sdk/v1/data/medication.py

@@ -0,0 +1,54 @@
+from django.db import models
+
+from canvas_sdk.v1.data.base import CommittableModelManager, ValueSetLookupQuerySet
+from canvas_sdk.v1.data.patient import Patient
+from canvas_sdk.v1.data.user import CanvasUser
+
+
+class MedicationQuerySet(ValueSetLookupQuerySet):
+    """MedicationQuerySet."""
+
+    pass
+
+
+class Medication(models.Model):
+    """Medication."""
+
+    class Meta:
+        managed = False
+        app_label = "canvas_sdk"
+        db_table = "canvas_sdk_data_api_medication_001"
+
+    objects = CommittableModelManager.from_queryset(MedicationQuerySet)()
+
+    id = models.UUIDField()
+    dbid = models.BigIntegerField(primary_key=True)
+    patient = models.ForeignKey(Patient, on_delete=models.DO_NOTHING, related_name="medications")
+    deleted = models.BooleanField()
+    entered_in_error = models.ForeignKey(CanvasUser, on_delete=models.DO_NOTHING)
+    committer = models.ForeignKey(CanvasUser, on_delete=models.DO_NOTHING)
+    status = models.CharField()
+    start_date = models.DateField()
+    end_date = models.DateField()
+    quantity_qualifier_description = models.CharField()
+    clinical_quantity_description = models.CharField()
+    potency_unit_code = models.CharField()
+    national_drug_code = models.CharField()
+    erx_quantity = models.CharField()
+
+
+class MedicationCoding(models.Model):
+    """MedicationCoding."""
+
+    class Meta:
+        managed = False
+        app_label = "canvas_sdk"
+        db_table = "canvas_sdk_data_api_medicationcoding_001"
+
+    dbid = models.BigIntegerField(primary_key=True)
+    system = models.CharField()
+    version = models.CharField()
+    code = models.CharField()
+    display = models.CharField()
+    user_selected = models.BooleanField()
+    medication = models.ForeignKey(Medication, on_delete=models.DO_NOTHING, related_name="codings")