canvas 0.1.12__py3-none-any.whl → 0.1.14__py3-none-any.whl

canvas_sdk/commands/tests/tests.py

@@ -1,3 +1,4 @@
+import decimal
 from datetime import datetime
 
 import pytest
@@ -20,10 +21,10 @@ from canvas_sdk.commands import (
 )
 from canvas_sdk.commands.constants import Coding
 from canvas_sdk.commands.tests.test_utils import (
+    MaskedValue,
     fake,
     get_field_type,
-    raises_missing_error,
-    raises_none_error,
+    raises_none_error_for_effect_method,
     raises_wrong_type_error,
 )
 
@@ -57,7 +58,6 @@ from canvas_sdk.commands.tests.test_utils import (
                 "icd10_codes",
                 "sig",
                 "days_supply",
-                "quantity_to_dispense",
                 "type_to_dispense",
                 "refills",
                 "substitutions",
@@ -97,15 +97,11 @@ def test_command_raises_generic_error_when_kwarg_given_incorrect_type(
     ),
     fields_to_test: tuple[str],
 ) -> None:
-    schema = Command.model_json_schema()
-    schema["required"].append("note_id")
-    required_fields = {k: v for k, v in schema["properties"].items() if k in schema["required"]}
-    base = {field: fake(props, Command) for field, props in required_fields.items()}
     for field in fields_to_test:
-        raises_wrong_type_error(base, Command, field)
-        if field in required_fields:
-            raises_missing_error(base, Command, field)
-            raises_none_error(base, Command, field)
+        raises_wrong_type_error(Command, field)
+
+    for method in ["originate", "edit", "delete", "commit", "enter_in_error"]:
+        raises_none_error_for_effect_method(Command, method)
 
 
 @pytest.mark.parametrize(
@@ -113,69 +109,101 @@ def test_command_raises_generic_error_when_kwarg_given_incorrect_type(
     [
         (
             PlanCommand,
-            {"narrative": "yo", "user_id": 1},
-            "1 validation error for PlanCommand\n  Value error, Command should have either a note_id or a command_uuid. [type=value",
-            {"narrative": "yo", "note_id": 1, "user_id": 1},
+            {"narrative": "yo", "user_id": 5, "note_uuid": 1},
+            "1 validation error for PlanCommand\nnote_uuid\n  Input should be a valid string [type=string_type",
+            {"narrative": "yo", "note_uuid": "00000000-0000-0000-0000-000000000000", "user_id": 1},
         ),
         (
             PlanCommand,
-            {"narrative": "yo", "user_id": 1, "note_id": None},
-            "1 validation error for PlanCommand\n  Value error, Command should have either a note_id or a command_uuid. [type=value",
-            {"narrative": "yo", "note_id": 1, "user_id": 1},
+            {"narrative": "yo", "user_id": 5, "note_uuid": "5", "command_uuid": 5},
+            "1 validation error for PlanCommand\ncommand_uuid\n  Input should be a valid string [type=string_type",
+            {"narrative": "yo", "user_id": 5, "note_uuid": "5", "command_uuid": "5"},
         ),
         (
             PlanCommand,
-            {"narrative": "yo", "user_id": 5, "note_id": "100"},
-            "1 validation error for PlanCommand\nnote_id\n  Input should be a valid integer [type=int_type",
-            {"narrative": "yo", "note_id": 1, "user_id": 1},
+            {"narrative": "yo", "note_uuid": "5", "command_uuid": "4", "user_id": "5"},
+            "1 validation error for PlanCommand\nuser_id\n  Input should be a valid integer [type=int_type",
+            {"narrative": "yo", "note_uuid": "5", "command_uuid": "4", "user_id": 5},
         ),
         (
             ReasonForVisitCommand,
-            {"note_id": 1, "user_id": 1, "structured": True},
-            "1 validation error for ReasonForVisitCommand\n  Value error, Structured RFV should have a coding.",
-            {"note_id": 1, "user_id": 1, "structured": False},
+            {"note_uuid": "00000000-0000-0000-0000-000000000000", "user_id": 1, "structured": True},
+            "1 validation error for ReasonForVisitCommand\n  Structured RFV should have a coding",
+            {
+                "note_uuid": "00000000-0000-0000-0000-000000000000",
+                "user_id": 1,
+                "structured": False,
+            },
         ),
         (
             ReasonForVisitCommand,
-            {"note_id": 1, "user_id": 1, "coding": {"code": "x"}},
+            {
+                "note_uuid": "00000000-0000-0000-0000-000000000000",
+                "user_id": 1,
+                "coding": {"code": "x"},
+            },
             "1 validation error for ReasonForVisitCommand\ncoding.system\n  Field required [type=missing",
-            {"note_id": 1, "user_id": 1},
+            {"note_uuid": "00000000-0000-0000-0000-000000000000", "user_id": 1},
         ),
         (
             ReasonForVisitCommand,
-            {"note_id": 1, "user_id": 1, "coding": {"code": 1, "system": "y"}},
+            {
+                "note_uuid": "00000000-0000-0000-0000-000000000000",
+                "user_id": 1,
+                "coding": {"code": 1, "system": "y"},
+            },
             "1 validation error for ReasonForVisitCommand\ncoding.code\n  Input should be a valid string [type=string_type",
-            {"note_id": 1, "user_id": 1},
+            {"note_uuid": "00000000-0000-0000-0000-000000000000", "user_id": 1},
         ),
         (
             ReasonForVisitCommand,
-            {"note_id": 1, "user_id": 1, "coding": {"code": None, "system": "y"}},
+            {
+                "note_uuid": "00000000-0000-0000-0000-000000000000",
+                "user_id": 1,
+                "coding": {"code": None, "system": "y"},
+            },
             "1 validation error for ReasonForVisitCommand\ncoding.code\n  Input should be a valid string [type=string_type",
-            {"note_id": 1, "user_id": 1},
+            {"note_uuid": "00000000-0000-0000-0000-000000000000", "user_id": 1},
         ),
         (
             ReasonForVisitCommand,
-            {"note_id": 1, "user_id": 1, "coding": {"system": "y"}},
+            {
+                "note_uuid": "00000000-0000-0000-0000-000000000000",
+                "user_id": 1,
+                "coding": {"system": "y"},
+            },
             "1 validation error for ReasonForVisitCommand\ncoding.code\n  Field required [type=missing",
-            {"note_id": 1, "user_id": 1},
+            {"note_uuid": "00000000-0000-0000-0000-000000000000", "user_id": 1},
         ),
         (
             ReasonForVisitCommand,
-            {"note_id": 1, "user_id": 1, "coding": {"code": "x", "system": 1}},
+            {
+                "note_uuid": "00000000-0000-0000-0000-000000000000",
+                "user_id": 1,
+                "coding": {"code": "x", "system": 1},
+            },
             "1 validation error for ReasonForVisitCommand\ncoding.system\n  Input should be a valid string [type=string_type",
-            {"note_id": 1, "user_id": 1},
+            {"note_uuid": "00000000-0000-0000-0000-000000000000", "user_id": 1},
         ),
         (
             ReasonForVisitCommand,
-            {"note_id": 1, "user_id": 1, "coding": {"code": "x", "system": None}},
+            {
+                "note_uuid": "00000000-0000-0000-0000-000000000000",
+                "user_id": 1,
+                "coding": {"code": "x", "system": None},
+            },
             "1 validation error for ReasonForVisitCommand\ncoding.system\n  Input should be a valid string [type=string_type",
-            {"note_id": 1, "user_id": 1},
+            {"note_uuid": "00000000-0000-0000-0000-000000000000", "user_id": 1},
         ),
         (
             ReasonForVisitCommand,
-            {"note_id": 1, "user_id": 1, "coding": {"code": "x", "system": "y", "display": 1}},
+            {
+                "note_uuid": "00000000-0000-0000-0000-000000000000",
+                "user_id": 1,
+                "coding": {"code": "x", "system": "y", "display": 1},
+            },
             "1 validation error for ReasonForVisitCommand\ncoding.display\n  Input should be a valid string [type=string_type",
-            {"note_id": 1, "user_id": 1},
+            {"note_uuid": "00000000-0000-0000-0000-000000000000", "user_id": 1},
         ),
     ],
 )
@@ -186,7 +214,9 @@ def test_command_raises_specific_error_when_kwarg_given_incorrect_type(
     valid_kwargs: dict,
 ) -> None:
     with pytest.raises(ValidationError) as e1:
-        Command(**err_kwargs)
+        cmd = Command(**err_kwargs)
+        cmd.originate()
+        cmd.edit()
     assert err_msg in repr(e1.value)
 
     cmd = Command(**valid_kwargs)
@@ -195,6 +225,8 @@ def test_command_raises_specific_error_when_kwarg_given_incorrect_type(
     key, value = list(err_kwargs.items())[-1]
     with pytest.raises(ValidationError) as e2:
         setattr(cmd, key, value)
+        cmd.originate()
+        cmd.edit()
     assert err_msg in repr(e2.value)
 
 
@@ -219,7 +251,7 @@ def test_command_raises_specific_error_when_kwarg_given_incorrect_type(
         ),
         (HistoryOfPresentIllnessCommand, ("narrative",)),
         (MedicationStatementCommand, ("fdb_code", "sig")),
-        (PlanCommand, ("narrative", "user_id", "command_uuid", "note_id")),
+        (PlanCommand, ("narrative", "user_id", "command_uuid", "note_uuid")),
         (
             PrescribeCommand,
             (
@@ -268,15 +300,12 @@ def test_command_allows_kwarg_with_correct_type(
     fields_to_test: tuple[str],
 ) -> None:
     schema = Command.model_json_schema()
-    schema["required"].append("note_id")
-    required_fields = {k: v for k, v in schema["properties"].items() if k in schema["required"]}
-    base = {field: fake(props, Command) for field, props in required_fields.items()}
 
     for field in fields_to_test:
-        field_type = get_field_type(Command.model_json_schema()["properties"][field])
+        field_type = get_field_type(schema["properties"][field])
 
         init_field_value = fake({"type": field_type}, Command)
-        init_kwargs = base | {field: init_field_value}
+        init_kwargs = {field: init_field_value}
         cmd = Command(**init_kwargs)
         assert getattr(cmd, field) == init_field_value
 
@@ -284,24 +313,37 @@ def test_command_allows_kwarg_with_correct_type(
         setattr(cmd, field, updated_field_value)
         assert getattr(cmd, field) == updated_field_value
 
+    for method in ["originate", "edit", "delete", "commit", "enter_in_error"]:
+        required_fields = {
+            k: v
+            for k, v in schema["properties"].items()
+            if k in Command()._get_effect_method_required_fields(method)
+        }
+        base = {field: fake(props, Command) for field, props in required_fields.items()}
+        cmd = Command(**base)
+        effect = getattr(cmd, method)()
+        assert effect is not None
+
 
 @pytest.fixture(scope="session")
-def token() -> str:
-    return 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"]
+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
-def note_id(token: str) -> str:
+def note_uuid(token: MaskedValue) -> str:
     headers = {
-        "Authorization": f"Bearer {token}",
+        "Authorization": f"Bearer {token.value}",
         "Content-Type": "application/json",
         "Accept": "application/json",
     }
@@ -326,6 +368,9 @@ def command_type_map() -> dict[str, type]:
         "TextField": str,
         "ChoiceField": str,
         "DateField": datetime,
+        "ApproximateDateField": datetime,
+        "IntegerField": int,
+        "DecimalField": decimal.Decimal,
     }
 
 
@@ -334,14 +379,12 @@ def command_type_map() -> dict[str, type]:
     "Command",
     [
         (AssessCommand),
-        # todo: add Diagnose once it has an adapter in home-app
-        # (DiagnoseCommand),
+        (DiagnoseCommand),
         (GoalCommand),
         (HistoryOfPresentIllnessCommand),
         (MedicationStatementCommand),
         (PlanCommand),
-        # todo: add Prescribe once its been refactored
-        # (PrescribeCommand),
+        (PrescribeCommand),
         (QuestionnaireCommand),
         (ReasonForVisitCommand),
         (StopMedicationCommand),
@@ -349,9 +392,9 @@ def command_type_map() -> dict[str, type]:
     ],
 )
 def test_command_schema_matches_command_api(
-    token: str,
+    token: MaskedValue,
     command_type_map: dict[str, str],
-    note_id: str,
+    note_uuid: str,
     Command: (
         AssessCommand
         | DiagnoseCommand
@@ -367,8 +410,8 @@ def test_command_schema_matches_command_api(
     ),
 ) -> None:
     # first create the command in the new note
-    data = {"noteKey": note_id, "schemaKey": Command.Meta.key}
-    headers = {"Authorization": f"Bearer {token}"}
+    data = {"noteKey": note_uuid, "schemaKey": Command.Meta.key}
+    headers = {"Authorization": f"Bearer {token.value}"}
     url = f"{settings.INTEGRATION_TEST_URL}/core/api/v1/commands/"
     command_resp = requests.post(url, headers=headers, data=data).json()
     assert "uuid" in command_resp
@@ -396,7 +439,15 @@ def test_command_schema_matches_command_api(
         expected_type = expected_field["type"]
         if expected_type is Coding:
             expected_type = expected_type.__annotations__["code"]
-        assert expected_type == command_type_map.get(actual_field["type"])
+
+        actual_type = command_type_map.get(actual_field["type"])
+        if actual_field["type"] == "AutocompleteField" and name[-1] == "s":
+            # this condition initially created for Prescribe.indications,
+            # but could apply to other AutocompleteField fields that are lists
+            # making the assumption here that if the field ends in 's' (like indications), it is a list
+            actual_type = list[actual_type]  # type: ignore
+
+        assert expected_type == actual_type
 
         if (choices := actual_field["choices"]) is None:
             assert expected_field["choices"] is None

canvas_sdk/data/__init__.py

@@ -0,0 +1 @@
+from .base import DataModel

canvas_sdk/data/base.py

@@ -0,0 +1,22 @@
+from pydantic_core import ValidationError
+
+from canvas_sdk.base import Model
+
+
+class DataModel(Model):
+    class Meta:
+        update_required_fields = ("id",)
+
+    def model_dump_json_nested(self, *args, **kwargs) -> str:
+        """
+        Returns the model's json representation nested in a {"data": {..}} key.
+        """
+        return f'{{"data": {self.model_dump_json(*args, **kwargs)}}}'
+
+    def _validate_before_effect(self, method: str) -> None:
+        if method == "create" and getattr(self, "id", None):
+            error = self._create_error_detail(
+                "value", "create cannot be called on a model with an id", "id"
+            )
+            raise ValidationError.from_exception_data(self.__class__.__name__, [error])
+        super()._validate_before_effect(method)

canvas_sdk/data/patient.py

@@ -0,0 +1,6 @@
+from canvas_sdk.data import DataModel
+
+
+class Patient(DataModel):
+    id: str | None = None
+    # TODO - populate more attributes

canvas_sdk/data/staff.py

@@ -0,0 +1,6 @@
+from canvas_sdk.data import DataModel
+
+
+class Staff(DataModel):
+    id: str | None = None
+    # TODO - populate with first name, last name, additional attributes, etc.

canvas_sdk/data/task.py

@@ -0,0 +1,60 @@
+from datetime import datetime
+from enum import Enum
+
+from canvas_sdk.data import DataModel
+from canvas_sdk.data.patient import Patient
+from canvas_sdk.data.staff import Staff
+from canvas_sdk.effects import Effect, EffectType
+
+
+class Task(DataModel):
+    class Meta(DataModel.Meta):
+        create_required_fields = ("title",)
+
+    class Status(Enum):
+        COMPLETED = "Completed"
+        CLOSED = "Closed"
+        OPEN = "Open"
+
+    id: str | None = None
+    assignee: Staff | None = None
+    patient: Patient | None = None
+    title: str | None = None
+    due: datetime | None = None
+    status: Status | None = None
+    comments: "list[TaskComment] | None" = None
+    labels: list[str] | None = None
+
+    def create(self) -> Effect:
+        self._validate_before_effect("create")
+        return Effect(type=EffectType.CREATE_TASK, payload=self.model_dump_json_nested())
+
+    def update(self) -> Effect:
+        self._validate_before_effect("update")
+        payload = self.model_dump_json_nested(exclude_unset=True)
+        return Effect(type=EffectType.UPDATE_TASK, payload=payload)
+
+    def add_comment(self, comment: str) -> Effect:
+        if not self.id:
+            raise ValueError("Cannot add a comment to a Task without an id")
+        task_comment = TaskComment(task=self, body=comment)
+        task_comment._validate_before_effect("create")
+        return Effect(
+            type=EffectType.CREATE_TASK_COMMENT,
+            payload=task_comment.model_dump_json_nested(exclude_unset=True),
+        )
+
+
+class TaskComment(DataModel):
+    class Meta:
+        create_required_fields = (
+            "body",
+            "task",
+        )
+
+    id: str | None = None
+    task: Task | None = None
+    body: str | None = None
+
+
+Task.model_rebuild()

canvas_sdk/effects/__init__.py

@@ -1 +1 @@
-from generated.messages.effects_pb2 import Effect, EffectType
+from canvas_generated.messages.effects_pb2 import Effect, EffectType

canvas_sdk/effects/banner_alert/__init__.py

@@ -0,0 +1,2 @@
+from canvas_sdk.effects.banner_alert.add_banner_alert import AddBannerAlert
+from canvas_sdk.effects.banner_alert.remove_banner_alert import RemoveBannerAlert

canvas_sdk/effects/banner_alert/add_banner_alert.py

@@ -0,0 +1,49 @@
+from enum import Enum
+from typing import Any
+
+from pydantic import Field
+
+from canvas_sdk.effects.base import EffectType, _BaseEffect
+
+
+class AddBannerAlert(_BaseEffect):
+    """
+    An Effect that will result in a banner alert in Canvas.
+    """
+
+    class Meta:
+        effect_type = EffectType.ADD_BANNER_ALERT
+
+    class Placement(Enum):
+        CHART = "chart"
+        TIMELINE = "timeline"
+        APPOINTMENT_CARD = "appointment_card"
+        SCHEDULING_CARD = "scheduling_card"
+        PROFILE = "profile"
+
+    class Intent(Enum):
+        INFO = "info"
+        WARNING = "warning"
+        ALERT = "alert"
+
+    patient_id: str
+    key: str
+    narrative: str = Field(max_length=90)
+    placement: list[Placement] = Field(min_length=1)
+    intent: Intent
+    href: str | None = None
+
+    @property
+    def values(self) -> dict[str, Any]:
+        """The BannerAlert's values."""
+        return {
+            "narrative": self.narrative,
+            "placement": [p.value for p in self.placement],
+            "intent": self.intent.value,
+            "href": self.href,
+        }
+
+    @property
+    def effect_payload(self) -> dict[str, Any]:
+        """The payload of the effect."""
+        return {"patient": self.patient_id, "key": self.key, "data": self.values}

canvas_sdk/effects/banner_alert/remove_banner_alert.py

@@ -0,0 +1,20 @@
+from typing import Any
+
+from canvas_sdk.effects.base import EffectType, _BaseEffect
+
+
+class RemoveBannerAlert(_BaseEffect):
+    """
+    An Effect that will remove/inactivate a banner alert in Canvas.
+    """
+
+    class Meta:
+        effect_type = EffectType.REMOVE_BANNER_ALERT
+
+    patient_id: str
+    key: str
+
+    @property
+    def effect_payload(self) -> dict[str, Any]:
+        """The payload of the effect."""
+        return {"patient": self.patient_id, "key": self.key}

canvas_sdk/effects/base.py

@@ -1,8 +1,9 @@
+import json
 from typing import Any
 
 from pydantic import BaseModel, ConfigDict
 
-from canvas_sdk.effects import Effect
+from canvas_sdk.effects import Effect, EffectType
 
 
 class _BaseEffect(BaseModel):
@@ -11,7 +12,7 @@ class _BaseEffect(BaseModel):
     """
 
     class Meta:
-        effect_type = ""
+        effect_type = EffectType.UNKNOWN_EFFECT
 
     model_config = ConfigDict(strict=True, validate_assignment=True)
 
@@ -24,7 +25,4 @@ class _BaseEffect(BaseModel):
         return {"data": self.values}
 
     def apply(self) -> Effect:
-        return {
-            "type": self.Meta.effect_type,
-            "payload": self.effect_payload,
-        }
+        return Effect(type=self.Meta.effect_type, payload=json.dumps(self.effect_payload))

canvas_sdk/events/__init__.py

@@ -1 +1 @@
-from generated.messages.events_pb2 import Event, EventResponse, EventType
+from canvas_generated.messages.events_pb2 import Event, EventResponse, EventType

canvas_sdk/handlers/__init__.py

@@ -0,0 +1 @@
+from canvas_sdk.handlers.base import BaseHandler

canvas_sdk/handlers/base.py

@@ -0,0 +1,16 @@
+import json
+
+
+class BaseHandler:
+    """
+    The class that all handlers inherit from.
+    """
+
+    def __init__(self, event, secrets=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/handlers/cron_task.py

@@ -0,0 +1,35 @@
+from abc import abstractmethod
+
+import arrow
+from cron_converter import Cron
+
+from canvas_sdk.effects import Effect
+from canvas_sdk.events import EventType
+from canvas_sdk.handlers.base import BaseHandler
+
+
+class CronTask(BaseHandler):
+    """
+    A type of handler that executes periodically according to a provided schedule.
+    """
+
+    RESPONDS_TO = EventType.Name(EventType.CRON)
+
+    SCHEDULE: str = ""  # e.g. "* * * * *" for every minute.
+
+    @abstractmethod
+    def execute(self) -> list[Effect]:
+        """
+        Perform some work and return a list of effects.
+        """
+
+    def compute(self) -> list[Effect]:
+        """
+        See if the task should execute given the timestamp.
+        """
+        if not self.SCHEDULE:
+            raise ValueError("You must set a SCHEDULE.")
+        datetime = arrow.get(self.target).datetime
+        if datetime in Cron(self.SCHEDULE):
+            return self.execute()
+        return []

canvas_sdk/protocols/base.py

@@ -1,16 +1,7 @@
-import json
+from canvas_sdk.handlers.base import BaseHandler
 
 
-class BaseProtocol:
+class BaseProtocol(BaseHandler):
     """
     The class that protocols inherit from.
     """
-
-    def __init__(self, event, secrets=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/utils/stats.py

@@ -0,0 +1,27 @@
+from time import time
+from typing import Any
+
+
+def get_duration_ms(start_time: time) -> int:
+    return int((time() - start_time) * 1000)
+
+
+LINE_PROTOCOL_TRANSLATION = str.maketrans(
+    {
+        ",": r"\,",
+        "=": r"\=",
+        " ": r"\ ",
+        ":": r"__",
+    }
+)
+
+
+def tags_to_line_protocol(tags: dict[str, Any]) -> str:
+    """Generate a tags string compatible with the InfluxDB line protocol.
+
+    See: https://docs.influxdata.com/influxdb/v1.1/write_protocols/line_protocol_tutorial/
+    """
+    return ",".join(
+        f"{tag_name}={str(tag_value).translate(LINE_PROTOCOL_TRANSLATION)}"
+        for tag_name, tag_value in tags.items()
+    )

logger/__init__.py

@@ -0,0 +1,2 @@
+from logger.logger import PluginLogger
+log = PluginLogger()