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

canvas_sdk/commands/commands/task.py

@@ -0,0 +1,52 @@
+from datetime import date
+from enum import Enum, StrEnum
+
+from typing_extensions import TypedDict, NotRequired
+
+from canvas_sdk.commands.base import _BaseCommand as BaseCommand
+
+
+class AssigneeType(StrEnum):
+    """The type of assigner for a Task command."""
+
+    ROLE = "role"
+    TEAM = "team"
+    UNASSIGNED = "unassigned"
+    STAFF = "staff"
+
+
+class TaskAssigner(TypedDict):
+    """A class for managing an assign for a Task command."""
+
+    to: AssigneeType
+    id: NotRequired[int]
+
+
+class TaskCommand(BaseCommand):
+    """A class for managing a Task command within a specific note."""
+
+    class Meta:
+        key = "task"
+        commit_required_fields = (
+            "title",
+            "assign_to",
+        )
+
+    title: str = ""
+    assign_to: TaskAssigner | None = None
+    due_date: date | None = None
+    comment: str | None = None
+    labels: list[str] | None = None
+    linked_items_urns: list[str] | None = None
+
+    @property
+    def values(self) -> dict:
+        """The Task command's field values."""
+        return {
+            "title": self.title,
+            "assign_to": self.assign_to,
+            "due_date": self.due_date.isoformat() if self.due_date else None,
+            "comment": self.comment,
+            "labels": self.labels,
+            "linked_items_urns": self.linked_items_urns,
+        }

canvas_sdk/commands/commands/update_diagnosis.py

@@ -0,0 +1,27 @@
+from canvas_sdk.commands.base import _BaseCommand as BaseCommand
+
+
+class UpdateDiagnosisCommand(BaseCommand):
+    """A class for managing an Update Diagnosis command within a specific note."""
+
+    class Meta:
+        key = "updateDiagnosis"
+        commit_required_fields = (
+            "condition_code",
+            "new_condition_code",
+        )
+
+    condition_code: str | None = None
+    new_condition_code: str | None = None
+    background: str | None = None
+    narrative: str | None = None
+
+    @property
+    def values(self) -> dict:
+        """The Update Diagnosis command's field values."""
+        return {
+            "condition_code": self.condition_code,
+            "new_condition_code": self.new_condition_code,
+            "background": self.background,
+            "narrative": self.narrative,
+        }

canvas_sdk/commands/commands/update_goal.py

@@ -11,7 +11,7 @@ class UpdateGoalCommand(_BaseCommand):
 
     class Meta:
         key = "updateGoal"
-        originate_required_fields = ("goal_id",)
+        commit_required_fields = ("goal_id",)
 
     class AchievementStatus(Enum):
         IN_PROGRESS = "in-progress"

canvas_sdk/commands/commands/vitals.py

@@ -0,0 +1,78 @@
+from pydantic import conint, constr
+from typing import Optional
+from enum import Enum
+
+from canvas_sdk.commands.base import _BaseCommand as BaseCommand
+
+
+class VitalsCommand(BaseCommand):
+
+    class Meta:
+        key = "vitals"
+        commit_required_fields = ()
+
+    class BodyTemperatureSite(Enum):
+        AXILLARY = 0
+        ORAL = 1
+        RECTAL = 2
+        TEMPORAL = 3
+        TYMPANIC = 4
+
+    class BloodPressureSite(Enum):
+        SITTING_RIGHT_UPPER = 0
+        SITTING_LEFT_UPPER = 1
+        SITTING_RIGHT_LOWER = 2
+        SITTING_LEFT_LOWER = 3
+        STANDING_RIGHT_UPPER = 4
+        STANDING_LEFT_UPPER = 5
+        STANDING_RIGHT_LOWER = 6
+        STANDING_LEFT_LOWER = 7
+        SUPINE_RIGHT_UPPER = 8
+        SUPINE_LEFT_UPPER = 9
+        SUPINE_RIGHT_LOWER = 10
+        SUPINE_LEFT_LOWER = 11
+
+    class PulseRhythm(Enum):
+        REGULAR = 0
+        IRREGULARLY_IRREGULAR = 1
+        REGULARLY_IRREGULAR = 2
+
+    height: conint(ge=10, le=108) | None = None
+    weight_lbs: conint(ge=1, le=1500) | None = None
+    weight_oz: int | None = None
+    waist_circumference: conint(ge=20, le=200) | None = None
+    body_temperature: conint(ge=85, le=107) | None = None
+    body_temperature_site: BodyTemperatureSite | None = None
+    blood_pressure_systole: conint(ge=30, le=305) | None = None
+    blood_pressure_diastole: conint(ge=20, le=180) | None = None
+    blood_pressure_position_and_site: BloodPressureSite | None = None
+    pulse: conint(ge=30, le=250) | None = None
+    pulse_rhythm: PulseRhythm | None = None
+    respiration_rate: conint(ge=6, le=60) | None = None
+    oxygen_saturation: conint(ge=60, le=100) | None = None
+    note: constr(max_length=150) | None = None
+
+    @property
+    def values(self) -> dict:
+        return {
+            "height": self.height,
+            "weight_lbs": self.weight_lbs,
+            "weight_oz": self.weight_oz,
+            "waist_circumference": self.waist_circumference,
+            "body_temperature": self.body_temperature,
+            "body_temperature_site": (
+                self.body_temperature_site.value if self.body_temperature_site else None
+            ),
+            "blood_pressure_systole": self.blood_pressure_systole,
+            "blood_pressure_diastole": self.blood_pressure_diastole,
+            "blood_pressure_position_and_site": (
+                self.blood_pressure_position_and_site.value
+                if self.blood_pressure_position_and_site
+                else None
+            ),
+            "pulse": self.pulse,
+            "pulse_rhythm": self.pulse_rhythm.value if self.pulse_rhythm else None,
+            "respiration_rate": self.respiration_rate,
+            "oxygen_saturation": self.oxygen_saturation,
+            "note": self.note,
+        }

canvas_sdk/commands/constants.py

@@ -7,3 +7,10 @@ class Coding(TypedDict):
     system: str
     code: str
     display: NotRequired[str]
+
+
+class ClinicalQuantity(TypedDict):
+    """A ClinicalQuantity for prescribe/refill commands."""
+
+    representative_ndc: str
+    ncpdp_quantity_qualifier_code: str

canvas_sdk/commands/tests/protocol/tests.py

@@ -0,0 +1,55 @@
+from datetime import datetime
+from typing import Any, Generator
+
+import pytest
+
+from canvas_sdk.commands.tests.test_utils import (
+    COMMANDS,
+    MaskedValue,
+    clean_up_files_and_plugins,
+    create_new_note,
+    get_original_note_body_commands,
+    get_token,
+    install_plugin,
+    trigger_plugin_event,
+    write_protocol_code,
+)
+
+
+@pytest.fixture(scope="session")
+def token() -> MaskedValue:
+    return get_token()
+
+
+@pytest.fixture(scope="session")
+def new_note(token: MaskedValue) -> dict:
+    return create_new_note(token)
+
+
+@pytest.fixture(scope="session")
+def plugin_name() -> str:
+    return f"commands{datetime.now().timestamp()}".replace(".", "")
+
+
+@pytest.fixture(autouse=True, scope="session")
+def write_and_install_protocol_and_clean_up(
+    plugin_name: str, token: MaskedValue, new_note: dict
+) -> Generator[Any, Any, Any]:
+    write_protocol_code(new_note["externallyExposableId"], plugin_name, COMMANDS)
+    install_plugin(plugin_name, token)
+
+    yield
+
+    clean_up_files_and_plugins(plugin_name, token)
+
+
+@pytest.mark.integtest
+def test_protocol_that_inserts_every_command(token: MaskedValue, new_note: dict) -> None:
+    trigger_plugin_event(token)
+
+    commands_in_body = get_original_note_body_commands(new_note["id"], token)
+    command_keys = [c.Meta.key for c in COMMANDS]
+
+    assert len(command_keys) == len(commands_in_body)
+    for i, command_key in enumerate(command_keys):
+        assert commands_in_body[i] == command_key

canvas_sdk/commands/tests/schema/tests.py

@@ -0,0 +1,104 @@
+import decimal
+from datetime import date, datetime
+from typing import get_origin
+
+import pytest
+import requests
+
+import settings
+from canvas_sdk.commands.base import _BaseCommand
+from canvas_sdk.commands.constants import Coding, ClinicalQuantity
+from canvas_sdk.commands.tests.test_utils import (
+    COMMANDS,
+    MaskedValue,
+    create_new_note,
+    get_token,
+)
+
+
+@pytest.fixture(scope="session")
+def token() -> MaskedValue:
+    return get_token()
+
+
+@pytest.fixture(scope="session")
+def new_note(token: MaskedValue) -> dict:
+    return create_new_note(token)
+
+
+@pytest.fixture
+def command_type_map() -> dict[str, type]:
+    return {
+        "AutocompleteField": str,
+        "MultiLineTextField": str,
+        "TextField": str,
+        "ChoiceField": str,
+        "DateField": datetime,
+        "ApproximateDateField": date,
+        "IntegerField": int,
+        "DecimalField": decimal.Decimal,
+    }
+
+
+@pytest.mark.integtest
+@pytest.mark.parametrize(
+    "Command",
+    COMMANDS,
+)
+def test_command_schema_matches_command_api(
+    token: MaskedValue,
+    command_type_map: dict[str, str],
+    new_note: dict,
+    Command: _BaseCommand,
+) -> None:
+    # first create the command in the new note
+    data = {"noteKey": new_note["externallyExposableId"], "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
+    command_uuid = command_resp["uuid"]
+
+    # next, request the fields of the newly created command
+    url = f"{settings.INTEGRATION_TEST_URL}/core/api/v1/commands/{command_uuid}/fields/"
+    command_fields_resp = requests.get(url, headers=headers).json()
+    assert command_fields_resp["schema"] == Command.Meta.key
+
+    command_fields = command_fields_resp["fields"]
+    if Command.Meta.key == "questionnaire":
+        # questionnaire's fields vary per questionnaire, so just check the first two fields which never vary
+        command_fields = command_fields[:2]
+    expected_fields = Command.command_schema()
+    assert len(command_fields) == len(expected_fields)
+
+    for actual_field in command_fields:
+        name = actual_field["name"]
+        assert name in expected_fields
+        expected_field = expected_fields[name]
+
+        assert expected_field["required"] == actual_field["required"]
+
+        expected_type = expected_field["type"]
+        if expected_type is Coding:
+            expected_type = expected_type.__annotations__["code"]
+
+        if expected_type is ClinicalQuantity:
+            expected_type = expected_type.__annotations__["representative_ndc"]
+
+        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
+            assert get_origin(expected_type) == list
+
+        else:
+            assert expected_type == actual_type
+
+        if (choices := actual_field["choices"]) is None:
+            assert expected_field["choices"] is None
+            continue
+
+        assert len(expected_field["choices"]) == len(choices)
+        for choice in choices:
+            assert choice["value"] in expected_field["choices"]

canvas_sdk/commands/tests/test_utils.py

@@ -1,12 +1,20 @@
 import random
+import shutil
 import string
+from contextlib import chdir
 from datetime import datetime
 from decimal import Decimal
+from pathlib import Path
 from typing import Any
 
 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 import (
     AssessCommand,
     DiagnoseCommand,
@@ -18,12 +26,16 @@ from canvas_sdk.commands import (
     QuestionnaireCommand,
     ReasonForVisitCommand,
     StopMedicationCommand,
+    UpdateGoalCommand,
 )
-from canvas_sdk.commands.constants import Coding
+from canvas_sdk.commands.base import _BaseCommand
+from canvas_sdk.commands.constants import Coding, ClinicalQuantity
+
+runner = CliRunner()
 
 
 class MaskedValue:
-    def __init__(self, value):
+    def __init__(self, value: str) -> None:
         self.value = value
 
     def __repr__(self) -> str:
@@ -82,8 +94,14 @@ def fake(
             num_items = random.randint(0, 5)
             item_props = field_props["anyOf"][0]["items"]
             return [fake(item_props, Command) for i in range(num_items)]
+        case "list":
+            num_items = random.randint(0, field_props.get("maxItems", 5))
+            item_props = field_props.get("items")
+            return [fake(item_props, Command) for i in range(num_items)] if item_props else []
         case "Coding":
             return Coding(system=random_string(), code=random_string(), display=random_string())
+        case "ClinicalQuantity":
+            return ClinicalQuantity(representative_ndc="ndc", ncpdp_quantity_qualifier_code="code")
     if t[0].isupper():
         return random.choice([e for e in getattr(Command, t)])
 
@@ -122,7 +140,9 @@ def raises_wrong_type_error(
     assert f"1 validation error for {Command.__name__}\n{field}" in err_msg1
     assert f"1 validation error for {Command.__name__}\n{field}" in err_msg2
 
-    field_type = "dictionary" if field_type == "Coding" else field_type
+    field_type = (
+        "dictionary" if field_type == "Coding" or field_type == "ClinicalQuantity" else field_type
+    )
     if field_type == "number":
         assert f"Input should be an instance of Decimal" in err_msg1
         assert f"Input should be an instance of Decimal" in err_msg2
@@ -149,14 +169,158 @@ def raises_none_error_for_effect_method(
     ),
     method: str,
 ) -> None:
+    cmd_name = Command.__name__
+    cmd_name_article = "an" if cmd_name.startswith(("A", "E", "I", "O", "U")) else "a"
+
     cmd = Command()
     method_required_fields = cmd._get_effect_method_required_fields(method)
     with pytest.raises(ValidationError) as e:
         getattr(cmd, method)()
     e_msg = repr(e.value)
-    assert f"{len(method_required_fields)} validation errors for {Command.__name__}" in e_msg
-    for f in method_required_fields:
+    missing_fields = [field for field in method_required_fields if getattr(cmd, field) is None]
+    num_errs = len(missing_fields)
+    assert f"{num_errs} validation error{'s' if num_errs > 1 else ''} for {cmd_name}" in e_msg
+
+    for f in missing_fields:
         assert (
-            f"Field '{f}' is required to {method.replace('_', ' ')} a command [type=missing, input_value=None, input_type=NoneType]"
+            f"Field '{f}' is required to {method.replace('_', ' ')} {cmd_name_article} {cmd_name} [type=missing, input_value=None, input_type=NoneType]"
             in e_msg
         )
+
+
+def write_protocol_code(note_uuid: str, plugin_name: str, commands: list[_BaseCommand]) -> None:
+    imports = ", ".join([c.__name__ for c in commands])
+    effects = ", ".join([f"{c.__name__}(note_uuid='{note_uuid}').originate()" for c in commands])
+
+    protocol_code = f"""from canvas_sdk.commands import {imports}
+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 [{effects}]
+"""
+
+    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(protocol_code)
+    protocol.close()
+
+
+def install_plugin(plugin_name: str, token: MaskedValue) -> None:
+    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}"},
+    )
+
+
+def trigger_plugin_event(token: MaskedValue) -> None:
+    requests.post(
+        f"{settings.INTEGRATION_TEST_URL}/api/Note/",
+        headers={
+            "Authorization": f"Bearer {token.value}",
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+        },
+        json={
+            "patient": 2,
+            "provider": 1,
+            "note_type": "office",
+            "note_type_version": 1,
+            "lastModifiedBySessionKey": "8fee3c03a525cebee1d8a6b8e63dd4dg",
+        },
+    )
+
+
+def get_original_note_body_commands(new_note_id: int, token: MaskedValue) -> list[str]:
+    original_note = requests.get(
+        f"{settings.INTEGRATION_TEST_URL}/api/Note/{new_note_id}",
+        headers={
+            "Authorization": f"Bearer {token.value}",
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+        },
+    ).json()
+
+    body = original_note["body"]
+    return [
+        line["value"]
+        for line in body
+        if "data" in line
+        and "commandUuid" in line["data"]
+        and "id" in line["data"]
+        and line["type"] == "command"
+    ]
+
+
+def clean_up_files_and_plugins(plugin_name: str, token: MaskedValue) -> None:
+    # 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}"},
+    )
+
+
+# For reuse with the protocol code
+COMMANDS = [
+    AssessCommand,
+    DiagnoseCommand,
+    GoalCommand,
+    HistoryOfPresentIllnessCommand,
+    MedicationStatementCommand,
+    PlanCommand,
+    PrescribeCommand,
+    QuestionnaireCommand,
+    ReasonForVisitCommand,
+    StopMedicationCommand,
+    UpdateGoalCommand,
+]
+
+
+def create_new_note(token: MaskedValue) -> dict:
+    headers = {
+        "Authorization": f"Bearer {token.value}",
+        "Content-Type": "application/json",
+        "Accept": "application/json",
+    }
+    data = {
+        "patient": 1,
+        "provider": 1,
+        "note_type": "office",
+        "note_type_version": 1,
+        "lastModifiedBySessionKey": "8fee3c03a525cebee1d8a6b8e63dd4dg",
+    }
+    return requests.post(
+        f"{settings.INTEGRATION_TEST_URL}/api/Note/", headers=headers, json=data
+    ).json()
+
+
+def get_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"]
+    )