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

canvas_generated/messages/events_pb2.pyi

@@ -560,6 +560,8 @@ class EventType(int, metaclass=_enum_type_wrapper.EnumTypeWrapper):
     PATIENT_CHART__CONDITIONS: _ClassVar[EventType]
     PATIENT_CHART_SUMMARY__SECTION_CONFIGURATION: _ClassVar[EventType]
     CLAIM__CONDITIONS: _ClassVar[EventType]
+    PLUGIN_CREATED: _ClassVar[EventType]
+    PLUGIN_UPDATED: _ClassVar[EventType]
 UNKNOWN: EventType
 ALLERGY_INTOLERANCE_CREATED: EventType
 ALLERGY_INTOLERANCE_UPDATED: EventType
@@ -1111,6 +1113,8 @@ VITALS_COMMAND__POST_EXECUTE_ACTION: EventType
 PATIENT_CHART__CONDITIONS: EventType
 PATIENT_CHART_SUMMARY__SECTION_CONFIGURATION: EventType
 CLAIM__CONDITIONS: EventType
+PLUGIN_CREATED: EventType
+PLUGIN_UPDATED: EventType
 
 class Event(_message.Message):
     __slots__ = ("type", "target", "context")

canvas_sdk/base.py

@@ -31,7 +31,8 @@ class Model(BaseModel):
 
     def _get_error_details(self, method: Any) -> list[InitErrorDetails]:
         required_fields = self._get_effect_method_required_fields(method)
-        class_name = self.__repr_name__()
+        class_name = self.__repr_name__()  # type: ignore[misc]
+
         class_name_article = "an" if class_name.startswith(("A", "E", "I", "O", "U")) else "a"
         return [
             self._create_error_detail(

canvas_sdk/commands/base.py

@@ -2,7 +2,7 @@ import json
 import re
 from enum import EnumType
 from types import NoneType, UnionType
-from typing import Any, Literal, Tuple, Union, get_args, get_origin
+from typing import Any, Literal, Tuple, Union, cast, get_args, get_origin
 
 from canvas_sdk.base import Model
 from canvas_sdk.commands.constants import Coding
@@ -25,9 +25,7 @@ class _BaseCommand(Model):
     note_uuid: str | None = None
     command_uuid: str | None = None
 
-    def _get_effect_method_required_fields(
-        self, method: Literal["originate", "edit", "delete", "commit", "enter_in_error"]
-    ) -> tuple:
+    def _get_effect_method_required_fields(self, method: str) -> tuple:
         base_required_fields: tuple = getattr(
             _BaseCommand.Meta, f"{method}_required_fields", tuple()
         )
@@ -52,7 +50,7 @@ class _BaseCommand(Model):
         return schema.get("$defs", {}).get(choice_key, {}).get("enum")
 
     @classmethod
-    def _get_property_type(cls, name: str) -> type:
+    def _get_property_type(cls, name: str) -> type | None:
         annotation = cls.model_fields[name].annotation
         origin = get_origin(annotation)
 
@@ -89,7 +87,7 @@ class _BaseCommand(Model):
         """Originate a new command in the note body."""
         self._validate_before_effect("originate")
         return Effect(
-            type=EffectType.Value(f"ORIGINATE_{self.constantized_key()}_COMMAND"),
+            type=f"ORIGINATE_{self.constantized_key()}_COMMAND",
             payload=json.dumps(
                 {
                     "note": self.note_uuid,
@@ -101,37 +99,39 @@ class _BaseCommand(Model):
     def edit(self) -> Effect:
         """Edit the command."""
         self._validate_before_effect("edit")
-        return {
-            "type": f"EDIT_{self.constantized_key()}_COMMAND",
-            "payload": {
-                "command": self.command_uuid,
-                "data": self.values,
-            },
-        }
+        return Effect(
+            type=f"EDIT_{self.constantized_key()}_COMMAND",
+            payload=json.dumps(
+                {
+                    "command": self.command_uuid,
+                    "data": self.values,
+                }
+            ),
+        )
 
     def delete(self) -> Effect:
         """Delete the command."""
         self._validate_before_effect("delete")
-        return {
-            "type": f"DELETE_{self.constantized_key()}_COMMAND",
-            "payload": {"command": self.command_uuid},
-        }
+        return Effect(
+            type=f"DELETE_{self.constantized_key()}_COMMAND",
+            payload=json.dumps({"command": self.command_uuid}),
+        )
 
     def commit(self) -> Effect:
         """Commit the command."""
         self._validate_before_effect("commit")
-        return {
-            "type": f"COMMIT_{self.constantized_key()}_COMMAND",
-            "payload": {"command": self.command_uuid},
-        }
+        return Effect(
+            type=f"COMMIT_{self.constantized_key()}_COMMAND",
+            payload=json.dumps({"command": self.command_uuid}),
+        )
 
     def enter_in_error(self) -> Effect:
         """Mark the command as entered-in-error."""
         self._validate_before_effect("enter_in_error")
-        return {
-            "type": f"ENTER_IN_ERROR_{self.constantized_key()}_COMMAND",
-            "payload": {"command": self.command_uuid},
-        }
+        return Effect(
+            type=f"ENTER_IN_ERROR_{self.constantized_key()}_COMMAND",
+            payload=json.dumps({"command": self.command_uuid}),
+        )
 
     def recommend(self, title: str = "", button: str | None = None) -> Recommendation:
         """Returns a command recommendation to be inserted via Protocol Card."""

canvas_sdk/commands/tests/protocol/tests.py

@@ -31,10 +31,10 @@ def plugin_name() -> str:
     return f"commands{datetime.now().timestamp()}".replace(".", "")
 
 
-@pytest.fixture(autouse=True, scope="session")
+@pytest.fixture(scope="session")
 def write_and_install_protocol_and_clean_up(
     plugin_name: str, token: MaskedValue, new_note: dict
-) -> Generator[Any, Any, Any]:
+) -> Generator[None, None, None]:
     write_protocol_code(new_note["externallyExposableId"], plugin_name, COMMANDS)
     install_plugin(plugin_name, token)
 
@@ -44,7 +44,9 @@ def write_and_install_protocol_and_clean_up(
 
 
 @pytest.mark.integtest
-def test_protocol_that_inserts_every_command(token: MaskedValue, new_note: dict) -> None:
+def test_protocol_that_inserts_every_command(
+    write_and_install_protocol_and_clean_up: None, token: MaskedValue, new_note: dict
+) -> None:
     trigger_plugin_event(token)
 
     commands_in_body = get_original_note_body_commands(new_note["id"], token)

canvas_sdk/commands/tests/test_utils.py

@@ -5,7 +5,7 @@ from contextlib import chdir
 from datetime import datetime
 from decimal import Decimal
 from pathlib import Path
-from typing import Any
+from typing import Any, cast
 
 import pytest
 import requests
@@ -63,21 +63,7 @@ def random_string() -> str:
     return "".join(random.choices(string.ascii_uppercase + string.digits, k=7))
 
 
-def fake(
-    field_props: dict,
-    Command: (
-        AssessCommand
-        | DiagnoseCommand
-        | GoalCommand
-        | HistoryOfPresentIllnessCommand
-        | MedicationStatementCommand
-        | PlanCommand
-        | PrescribeCommand
-        | QuestionnaireCommand
-        | ReasonForVisitCommand
-        | StopMedicationCommand
-    ),
-) -> Any:
+def fake(field_props: dict, Command: type[_BaseCommand]) -> Any:
     t = get_field_type(field_props)
     match t:
         case "string":
@@ -107,18 +93,7 @@ def fake(
 
 
 def raises_wrong_type_error(
-    Command: (
-        AssessCommand
-        | DiagnoseCommand
-        | GoalCommand
-        | HistoryOfPresentIllnessCommand
-        | MedicationStatementCommand
-        | PlanCommand
-        | PrescribeCommand
-        | QuestionnaireCommand
-        | ReasonForVisitCommand
-        | StopMedicationCommand
-    ),
+    Command: type[_BaseCommand],
     field: str,
 ) -> None:
     field_props = Command.model_json_schema()["properties"][field]
@@ -155,18 +130,7 @@ def raises_wrong_type_error(
 
 
 def raises_none_error_for_effect_method(
-    Command: (
-        AssessCommand
-        | DiagnoseCommand
-        | GoalCommand
-        | HistoryOfPresentIllnessCommand
-        | MedicationStatementCommand
-        | PlanCommand
-        | PrescribeCommand
-        | QuestionnaireCommand
-        | ReasonForVisitCommand
-        | StopMedicationCommand
-    ),
+    Command: type[_BaseCommand],
     method: str,
 ) -> None:
     cmd_name = Command.__name__
@@ -214,7 +178,7 @@ class Protocol(BaseProtocol):
 
 def install_plugin(plugin_name: str, token: MaskedValue) -> None:
     requests.post(
-        plugin_url(settings.INTEGRATION_TEST_URL),
+        plugin_url(cast(str, 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}"},
@@ -267,7 +231,7 @@ def clean_up_files_and_plugins(plugin_name: str, token: MaskedValue) -> None:
 
     # disable
     requests.patch(
-        plugin_url(settings.INTEGRATION_TEST_URL, plugin_name),
+        plugin_url(cast(str, settings.INTEGRATION_TEST_URL), plugin_name),
         data={"is_enabled": False},
         headers={
             "Authorization": f"Bearer {token.value}",
@@ -275,13 +239,13 @@ def clean_up_files_and_plugins(plugin_name: str, token: MaskedValue) -> None:
     )
     # delete
     requests.delete(
-        plugin_url(settings.INTEGRATION_TEST_URL, plugin_name),
+        plugin_url(cast(str, settings.INTEGRATION_TEST_URL), plugin_name),
         headers={"Authorization": f"Bearer {token.value}"},
     )
 
 
 # For reuse with the protocol code
-COMMANDS = [
+COMMANDS: list[type[_BaseCommand]] = [
     AssessCommand,
     DiagnoseCommand,
     GoalCommand,

canvas_sdk/commands/tests/unit/tests.py

@@ -79,7 +79,7 @@ runner = CliRunner()
     ],
 )
 def test_command_raises_generic_error_when_kwarg_given_incorrect_type(
-    Command: _BaseCommand,
+    Command: type[_BaseCommand],
     fields_to_test: tuple[str],
 ) -> None:
     for field in fields_to_test:
@@ -179,7 +179,7 @@ def test_command_raises_generic_error_when_kwarg_given_incorrect_type(
     ],
 )
 def test_command_raises_specific_error_when_kwarg_given_incorrect_type(
-    Command: PlanCommand | ReasonForVisitCommand,
+    Command: type[PlanCommand] | type[ReasonForVisitCommand],
     err_kwargs: dict,
     err_msg: str,
     valid_kwargs: dict,
@@ -255,7 +255,7 @@ def test_command_raises_specific_error_when_kwarg_given_incorrect_type(
     ],
 )
 def test_command_allows_kwarg_with_correct_type(
-    Command: _BaseCommand,
+    Command: type[_BaseCommand],
     fields_to_test: tuple[str],
 ) -> None:
     schema = Command.model_json_schema()

canvas_sdk/data/client.py

@@ -54,7 +54,7 @@ class _CanvasGQLClient:
 
     def __init__(self) -> None:
         self.client = Client(
-            transport=AIOHTTPTransport(url=cast(str, GRAPHQL_ENDPOINT)),
+            transport=AIOHTTPTransport(url=GRAPHQL_ENDPOINT),
             # TODO: follow the documentation in the link below to specify a
             # cached copy of the schema
             # https://gql.readthedocs.io/en/stable/usage/validation.html#using-a-provided-schema

canvas_sdk/effects/banner_alert/tests.py

@@ -6,6 +6,7 @@ from typing import Any, Generator
 
 import pytest
 import requests
+from django.core.exceptions import ImproperlyConfigured
 from pydantic import ValidationError
 from typer.testing import CliRunner
 
@@ -49,10 +50,14 @@ def plugin_name() -> str:
     return f"addbanneralert{datetime.now().timestamp()}".replace(".", "")
 
 
-@pytest.fixture(autouse=True, scope="session")
+@pytest.fixture(scope="session")
 def write_and_install_protocol_and_clean_up(
     first_patient_id: str, plugin_name: str, token: MaskedValue
 ) -> Generator[Any, Any, Any]:
+
+    if not settings.INTEGRATION_TEST_URL:
+        raise ImproperlyConfigured("INTEGRATION_TEST_URL is not set")
+
     # write the protocol
     with chdir(Path("./custom-plugins")):
         runner.invoke(app, "init", input=plugin_name)
@@ -122,7 +127,10 @@ class Protocol(BaseProtocol):
 
 @pytest.mark.integtest
 def test_protocol_that_adds_banner_alert(
-    token: MaskedValue, plugin_name: str, first_patient_id: str
+    write_and_install_protocol_and_clean_up: None,
+    token: MaskedValue,
+    plugin_name: str,
+    first_patient_id: str,
 ) -> None:
     # trigger the event
     requests.post(
@@ -180,7 +188,7 @@ def test_protocol_that_adds_banner_alert(
     ],
 )
 def test_banner_alert_apply_method_succeeds_with_all_required_fields(
-    Effect: AddBannerAlert | RemoveBannerAlert, params: dict, expected_payload: str
+    Effect: type[AddBannerAlert] | type[RemoveBannerAlert], params: dict, expected_payload: str
 ) -> None:
     b = Effect()
     for k, v in params.items():
@@ -214,7 +222,7 @@ def test_banner_alert_apply_method_succeeds_with_all_required_fields(
     ],
 )
 def test_banner_alert_apply_method_raises_error_without_required_fields(
-    Effect: AddBannerAlert | RemoveBannerAlert, expected_err_msgs: str
+    Effect: type[AddBannerAlert] | type[RemoveBannerAlert], expected_err_msgs: str
 ) -> None:
     b = Effect()
     with pytest.raises(ValidationError) as e:

canvas_sdk/effects/protocol_card/protocol_card.py

@@ -49,7 +49,7 @@ class ProtocolCard(_BaseEffect):
     title: str = ""
     narrative: str = ""
     recommendations: list[Recommendation] = []
-    status: Status = Status.DUE  # type: ignore
+    status: Status = Status.DUE
     feedback_enabled: bool = False
 
     @property

canvas_sdk/effects/protocol_card/tests.py

@@ -107,7 +107,7 @@ def test_apply_method_raises_error_without_patient_id_and_key() -> None:
     ],
 )
 def test_add_recommendations(
-    init_params: dict[str, str], rec1_params: dict[Any, Any], rec2_params: dict[str, str]
+    init_params: dict[Any, Any], rec1_params: dict[Any, Any], rec2_params: dict[Any, Any]
 ) -> None:
     p = ProtocolCard(**init_params)
     p.add_recommendation(**rec1_params)
@@ -156,7 +156,7 @@ def test_add_recommendations(
     ],
 )
 def test_add_recommendations_from_commands(
-    Command: _BaseCommand, init_params: dict[str, str]
+    Command: type[_BaseCommand], init_params: dict[str, str]
 ) -> None:
     cmd = Command(**init_params)
     p = ProtocolCard(patient_id="uuid", key="commands")

canvas_sdk/protocols/clinical_quality_measure.py

@@ -21,6 +21,7 @@ class ClinicalQualityMeasure(BaseProtocol):
         show_in_population: bool = True
         can_be_snoozed: bool = True
         is_abstract: bool = False
+        is_predictive: bool = False
 
     @classmethod
     def _meta(cls) -> dict[str, Any]:

canvas_sdk/utils/http.py

@@ -1,6 +1,6 @@
 import time
 from functools import wraps
-from typing import Any, Callable, Mapping, TypeVar
+from typing import Any, Callable, Mapping, TypeVar, cast
 
 import requests
 import statsd
@@ -28,7 +28,7 @@ class Http:
             self.statsd_client.timing(f"http_{fn.__name__}", timing)
             return result
 
-        return wrapper
+        return cast(F, wrapper)
 
     @measure_time
     def get(

canvas_sdk/v1/data/common.py

@@ -0,0 +1,46 @@
+from django.db import models
+
+
+class DocumentReviewMode(models.TextChoices):
+    """Choices for document reviews."""
+
+    REVIEW_REQUIRED = "RR", "Review required"
+    ALREADY_REVIEWED_OFFLINE = "AR", "Already reviewed offline"
+    REVIEW_NOT_REQUIRED = "RN", "Review not required"
+
+
+class OrderStatus(models.TextChoices):
+    """Choices for Order statuses."""
+
+    PROPOSED = "proposed", "Proposed"
+    DRAFT = "draft", "Draft"
+    PLANNED = "planned", "Planned"
+    REQUESTED = "requested", "Requested"
+    RECEIVED = "received", "Received"
+    ACCEPTED = "accepted", "Accepted"
+    IN_PROGRESS = "in-progress", "In-progress"
+    REVIEW = "review", "Review"
+    COMPLETED = "completed", "Completed"
+    CANCELLED = "cancelled", "Cancelled"
+    SUSPENDED = "suspended", "Suspended"
+    REJECTED = "rejected", "Rejected"
+    FAILED = "failed", "Failed"
+    ENTERED_IN_ERROR = "EIE", "Entered in Error"
+
+
+class ReviewPatientCommunicationMethod(models.TextChoices):
+    """Choices for patient communication regarding reviews."""
+
+    DELEGATED_CALL_CAN_LEAVE_MESSAGE = "DM", "delegate call, can leave message"
+    DELEGATED_CALL_NEED_ANSWER = "DA", "delegate call, need patient to answer"
+    DELEGATED_LETTER = "DL", "delegate letter"
+    DO_NOT_COMMUNICATE = "DC", "do not communicate"
+    ALREADY_LEFT_MESSAGE = "AM", "already left message"
+    ALREADY_REVIEWED_WITH_PATIENT = "AR", "already reviewed with patient"
+
+
+class ReviewStatus(models.TextChoices):
+    """Status choices for reviews."""
+
+    STATUS_REVIEWING = "reviewing", "reviewing"
+    STATUS_REVIEWED = "reviewed", "reviewed"

canvas_sdk/v1/data/imaging.py

@@ -0,0 +1,102 @@
+from django.db import models
+
+from canvas_sdk.v1.data.common import (
+    DocumentReviewMode,
+    OrderStatus,
+    ReviewPatientCommunicationMethod,
+    ReviewStatus,
+)
+from canvas_sdk.v1.data.patient import Patient
+from canvas_sdk.v1.data.user import CanvasUser
+
+
+class ImagingOrder(models.Model):
+    """Model to read ImagingOrder data."""
+
+    class Meta:
+        managed = False
+        app_label = "canvas_sdk"
+        db_table = "canvas_sdk_data_api_imagingorder_001"
+
+    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)
+    patient = models.ForeignKey(Patient, on_delete=models.DO_NOTHING, related_name="imaging_orders")
+    # TODO - uncomment when Note model is complete
+    #  note = models.ForeigneKey(Note, on_delete=models.DO_NOTHING, related_name="imaging_orders")
+    imaging = models.CharField()
+    # TODO - uncomment when ServiceProvider model is complete
+    # imaging_center = models.ForeignKey(ServiceProvider, related_name="imaging_orders", null=True, on_delete=models.DO_NOTHING)
+    note_to_radiologist = models.CharField()
+    internal_comment = models.CharField()
+    status = models.CharField(choices=OrderStatus)
+    date_time_ordered = models.DateTimeField()
+    priority = models.CharField()
+    # TODO - uncomment when Staff model is complete
+    # ordering_provider = models.ForeignKey(Staff, on_delete=models.CASCADE, related_name="imaging_orders", null=True)
+    delegated = models.BooleanField(default=False)
+
+
+class ImagingReview(models.Model):
+    """Model to read ImagingReview data."""
+
+    class Meta:
+        managed = False
+        app_label = "canvas_sdk"
+        db_table = "canvas_sdk_data_api_imagingreview_001"
+
+    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)
+    patient_communication_method = models.CharField(choices=ReviewPatientCommunicationMethod)
+    # TODO  - uncomment when Note model is complete
+    # note = models.ForeignKey(Note, on_delete=models.DO_NOTHING, related_name="imaging_reviews")
+    internal_comment = models.CharField()
+    message_to_patient = models.CharField()
+    is_released_to_patient = models.BooleanField()
+    status = models.CharField(choices=ReviewStatus)
+    patient = models.ForeignKey(
+        Patient, on_delete=models.DO_NOTHING, related_name="imaging_reviews"
+    )
+
+
+class ImagingReport(models.Model):
+    """Model to read ImagingReport data."""
+
+    class ImagingReportSource(models.TextChoices):
+        RADIOLOGY_FROM_PATIENT = "RADIOLOGY_PATIENT", "Radiology Report From Patient"
+        VERBAL_FROM_PATIENT = "VERBAL_PATIENT", "Verbal Report From Patient"
+        DIRECTLY_REPORT = "DIRECTLY_RADIOLOGY", "Directly Radiology Report"
+
+    class Meta:
+        managed = False
+        app_label = "canvas_sdk"
+        db_table = "canvas_sdk_data_api_imagingreport_001"
+
+    id = models.UUIDField()
+    dbid = models.BigIntegerField(primary_key=True)
+    created = models.DateTimeField()
+    modified = models.DateTimeField()
+    review_mode = models.CharField(choices=DocumentReviewMode)
+    junked = models.BooleanField()
+    requires_signature = models.BooleanField()
+    assigned_date = models.DateTimeField()
+    patient = models.ForeignKey(
+        Patient, on_delete=models.DO_NOTHING, related_name="imaging_results"
+    )
+    order = models.ForeignKey(ImagingOrder, on_delete=models.DO_NOTHING, null=True)
+    source = models.CharField(choices=ImagingReportSource)
+    name = models.CharField()
+    result_date = models.DateField()
+    original_date = models.DateField()
+    review = models.ForeignKey(ImagingReview, null=True, on_delete=models.DO_NOTHING)