canvas 0.19.0__py3-none-any.whl → 0.20.0__py3-none-any.whl

canvas_sdk/commands/base.py

@@ -1,8 +1,10 @@
+import datetime
 import json
 import re
-from enum import EnumType
+from enum import Enum, EnumType
 from types import NoneType, UnionType
-from typing import Union, get_args, get_origin
+from typing import Any, Union, get_args, get_origin
+from uuid import UUID
 
 from canvas_sdk.base import Model
 from canvas_sdk.commands.constants import Coding
@@ -19,6 +21,32 @@ class _BaseCommand(Model):
         commit_required_fields = ("command_uuid",)
         enter_in_error_required_fields = ("command_uuid",)
 
+    # A set to track which fields have been modified.
+    _dirty_keys: set[str] = set()
+
+    def __init__(self, /, **data: Any) -> None:
+        """Initialize the command and mark all provided keys as dirty."""
+        super().__init__(**data)
+
+        # Initialize a set to track which fields have been modified.
+        self._dirty_keys = set()
+
+        # Explicitly mark all keys provided in the constructor as dirty.
+        self._dirty_keys.update(data.keys())
+
+    def __setattr__(self, name: str, value: Any) -> None:
+        """Set an attribute and mark it as dirty unless excluded."""
+        if not name.startswith("_") and name not in (
+            "note_uuid",
+            "command_uuid",
+        ):
+            self._dirty_keys.add(name)
+        super().__setattr__(name, value)
+
+    def is_dirty(self, key: str) -> bool:
+        """Returns True if the given property has been modified (i.e. marked as dirty), False otherwise."""
+        return key in self._dirty_keys
+
     def constantized_key(self) -> str:
         return re.sub(r"(?<!^)(?=[A-Z])", "_", self.Meta.key).upper()
 
@@ -32,7 +60,23 @@ class _BaseCommand(Model):
 
     @property
     def values(self) -> dict:
-        return {}
+        """Return a dictionary of modified attributes with type-specific transformations."""
+        result = {}
+        for key in self._dirty_keys:
+            value = getattr(self, key)
+            if isinstance(value, Enum):
+                # If it's an enum, use its .value.
+                result[key] = value.value if value else None
+            elif isinstance(value, datetime.date | datetime.datetime):
+                # If it's a date/datetime, use isoformat().
+                result[key] = value.isoformat() if value else None
+            elif isinstance(value, UUID):
+                # If it's a UUID, use its string representation.
+                result[key] = str(value) if value else None
+            else:
+                # For strings, integers, or any other type, return as is.
+                result[key] = value
+        return result
 
     @property
     def coding_filter(self) -> Coding | None:

canvas_sdk/commands/commands/allergy.py

@@ -37,15 +37,3 @@ class AllergyCommand(BaseCommand):
     severity: Severity | None = None
     narrative: str | None = None
     approximate_date: date | None = None
-
-    @property
-    def values(self) -> dict:
-        """The Allergy command's field values."""
-        return {
-            "allergy": self.allergy,
-            "severity": self.severity.value if self.severity else None,
-            "narrative": self.narrative,
-            "approximate_date": (
-                self.approximate_date.isoformat() if self.approximate_date else None
-            ),
-        }

canvas_sdk/commands/commands/assess.py

@@ -24,16 +24,6 @@ class AssessCommand(_BaseCommand):
     status: Status | None = None
     narrative: str | None = None
 
-    @property
-    def values(self) -> dict:
-        """The Assess command's field values."""
-        return {
-            "condition_id": self.condition_id,
-            "background": self.background,
-            "status": self.status.value if self.status else None,
-            "narrative": self.narrative,
-        }
-
 
 # how do we make sure that condition_id is a valid condition for the patient?
 

canvas_sdk/commands/commands/close_goal.py

@@ -12,14 +12,3 @@ class CloseGoalCommand(BaseCommand):
     goal_id: int | None = None
     achievement_status: GoalCommand.AchievementStatus | None = None
     progress: str | None = None
-
-    @property
-    def values(self) -> dict:
-        """The CloseGoal command's field values."""
-        return {
-            "goal_id": self.goal_id,
-            "achievement_status": (
-                self.achievement_status.value if self.achievement_status else None
-            ),
-            "progress": self.progress,
-        }

canvas_sdk/commands/commands/diagnose.py

@@ -18,17 +18,3 @@ class DiagnoseCommand(_BaseCommand):
     background: str | None = None
     approximate_date_of_onset: date | None = None
     today_assessment: str | None = None
-
-    @property
-    def values(self) -> dict:
-        """The Diagnose command's field values."""
-        return {
-            "icd10_code": self.icd10_code,
-            "background": self.background,
-            "approximate_date_of_onset": (
-                self.approximate_date_of_onset.isoformat()
-                if self.approximate_date_of_onset
-                else None
-            ),
-            "today_assessment": self.today_assessment,
-        }

canvas_sdk/commands/commands/family_history.py

@@ -11,8 +11,3 @@ class FamilyHistoryCommand(BaseCommand):
     family_history: str | None = None
     relative: str | None = None
     note: str | None = None
-
-    @property
-    def values(self) -> dict:
-        """The Family History command's field values."""
-        return {"family_history": self.family_history, "relative": self.relative, "note": self.note}

canvas_sdk/commands/commands/follow_up.py

@@ -0,0 +1,69 @@
+from datetime import date
+from typing import Literal
+from uuid import UUID
+
+from pydantic_core import InitErrorDetails
+
+from canvas_sdk.commands.base import _BaseCommand
+from canvas_sdk.commands.constants import Coding
+from canvas_sdk.v1.data import NoteType, ReasonForVisitSettingCoding
+
+
+class FollowUpCommand(_BaseCommand):
+    """A class for managing a Follow-Up command within a specific note."""
+
+    class Meta:
+        key = "followUp"
+        commit_required_fields = ("requested_date", "note_type")
+
+    structured: bool = False
+    requested_date: date | None = None
+    note_type_id: UUID | str | None = None
+    reason_for_visit: Coding | UUID | str | None = None
+    comment: str | None = None
+
+    def _get_error_details(
+        self, method: Literal["originate", "edit", "delete", "commit", "enter_in_error"]
+    ) -> list[InitErrorDetails]:
+        errors = super()._get_error_details(method)
+
+        if self.reason_for_visit:
+            if self.structured:
+                if isinstance(self.reason_for_visit, str | UUID):
+                    query = {"id": self.reason_for_visit}
+                    error_message = f"ReasonForVisitSettingCoding with id {self.reason_for_visit} does not exist."
+                else:
+                    query = {
+                        "code": self.reason_for_visit["code"],
+                        "system": self.reason_for_visit["system"],
+                    }
+                    error_message = f"ReasonForVisitSettingCoding with code {self.reason_for_visit['code']} and system {self.reason_for_visit['system']} does not exist."
+
+                if not ReasonForVisitSettingCoding.objects.filter(**query).exists():
+                    errors.append(
+                        self._create_error_detail("value", error_message, self.reason_for_visit)
+                    )
+            elif not isinstance(self.reason_for_visit, str):
+                errors.append(
+                    self._create_error_detail(
+                        "value",
+                        "reason for visit must be a string when structured is False.",
+                        self.reason_for_visit,
+                    )
+                )
+
+        if (
+            self.note_type_id
+            and not NoteType.objects.filter(
+                id=self.note_type_id, is_active=True, is_scheduleable=True
+            ).exists()
+        ):
+            errors.append(
+                self._create_error_detail(
+                    "value",
+                    f"NoteType with id {self.note_type_id} does not exist or is not scheduleable.",
+                    self.note_type_id,
+                )
+            )
+
+        return errors

canvas_sdk/commands/commands/goal.py

@@ -33,17 +33,3 @@ class GoalCommand(_BaseCommand):
     achievement_status: AchievementStatus | None = None
     priority: Priority | None = None
     progress: str | None = None
-
-    @property
-    def values(self) -> dict:
-        """The Goal command's field values."""
-        return {
-            "goal_statement": self.goal_statement,
-            "start_date": (self.start_date.isoformat() if self.start_date else None),
-            "due_date": (self.due_date.isoformat() if self.due_date else None),
-            "achievement_status": (
-                self.achievement_status.value if self.achievement_status else None
-            ),
-            "priority": (self.priority.value if self.priority else None),
-            "progress": self.progress,
-        }

canvas_sdk/commands/commands/history_present_illness.py

@@ -9,8 +9,3 @@ class HistoryOfPresentIllnessCommand(_BaseCommand):
         commit_required_fields = ("narrative",)
 
     narrative: str | None = None
-
-    @property
-    def values(self) -> dict:
-        """The HPI command's field values."""
-        return {"narrative": self.narrative}

canvas_sdk/commands/commands/instruct.py

@@ -10,8 +10,3 @@ class InstructCommand(BaseCommand):
 
     instruction: str | None = None
     comment: str | None = None
-
-    @property
-    def values(self) -> dict:
-        """The Instruct command's field values."""
-        return {"instruction": self.instruction, "comment": self.comment}

canvas_sdk/commands/commands/lab_order.py

@@ -1,4 +1,10 @@
+from typing import Literal
+
+from django.db.models.query_utils import Q
+from pydantic_core import InitErrorDetails
+
 from canvas_sdk.commands.base import _BaseCommand as BaseCommand
+from canvas_sdk.v1.data.lab import LabPartner, LabPartnerTest
 
 
 class LabOrderCommand(BaseCommand):
@@ -20,14 +26,56 @@ class LabOrderCommand(BaseCommand):
     fasting_required: bool = False
     comment: str | None = None
 
-    @property
-    def values(self) -> dict:
-        """The Lab Order command's field values."""
-        return {
-            "lab_partner": self.lab_partner,
-            "tests_order_codes": self.tests_order_codes,
-            "ordering_provider_key": self.ordering_provider_key,
-            "diagnosis_codes": self.diagnosis_codes,
-            "fasting_required": self.fasting_required,
-            "comment": self.comment,
-        }
+    def _get_error_details(
+        self, method: Literal["originate", "edit", "delete", "commit", "enter_in_error"]
+    ) -> list[InitErrorDetails]:
+        errors = super()._get_error_details(method)
+
+        lab_partner_obj = None
+        if self.lab_partner:
+            lab_partner_obj = (
+                LabPartner.objects.filter(Q(name=self.lab_partner) | Q(id=self.lab_partner))
+                .values("id", "dbid")
+                .first()
+            )
+            if not lab_partner_obj:
+                errors.append(
+                    self._create_error_detail(
+                        "value",
+                        f"lab partner with Id or Name {self.lab_partner} not found",
+                        self.lab_partner,
+                    )
+                )
+
+        if self.tests_order_codes:
+            if not lab_partner_obj:
+                errors.append(
+                    self._create_error_detail(
+                        "value", "lab partner is required to find tests", self.tests_order_codes
+                    )
+                )
+            else:
+                tests = LabPartnerTest.objects.filter(
+                    Q(order_code__in=self.tests_order_codes) | Q(id__in=self.tests_order_codes),
+                    lab_partner_id=lab_partner_obj["dbid"],
+                ).values_list("id", "order_code")
+
+                if tests.count() != len(self.tests_order_codes):
+                    missing_tests = [
+                        test
+                        for test in self.tests_order_codes
+                        if not any(
+                            test == str(test_id) or test == order_code
+                            for test_id, order_code in tests
+                        )
+                    ]
+
+                    errors.append(
+                        self._create_error_detail(
+                            "value",
+                            f"tests with order codes {missing_tests} not found",
+                            self.tests_order_codes,
+                        )
+                    )
+
+        return errors

canvas_sdk/commands/commands/medical_history.py

@@ -17,18 +17,3 @@ class MedicalHistoryCommand(BaseCommand):
     approximate_end_date: date | None = None
     show_on_condition_list: bool = True
     comments: str | None = Field(max_length=1000, default=None)
-
-    @property
-    def values(self) -> dict:
-        """The Medical History command's field values."""
-        return {
-            "past_medical_history": self.past_medical_history,
-            "approximate_start_date": (
-                self.approximate_start_date.isoformat() if self.approximate_start_date else None
-            ),
-            "approximate_end_date": (
-                self.approximate_end_date.isoformat() if self.approximate_end_date else None
-            ),
-            "show_on_condition_list": self.show_on_condition_list,
-            "comments": self.comments,
-        }

canvas_sdk/commands/commands/medication_statement.py

@@ -15,11 +15,6 @@ class MedicationStatementCommand(_BaseCommand):
     )
     sig: str | None = None
 
-    @property
-    def values(self) -> dict:
-        """The MedicationStatement command's field values."""
-        return {"fdb_code": self.fdb_code, "sig": self.sig}
-
 
 # how do we make sure fdb_code is a valid code?
 

canvas_sdk/commands/commands/past_surgical_history.py

@@ -15,14 +15,3 @@ class PastSurgicalHistoryCommand(BaseCommand):
     past_surgical_history: str | None = None
     approximate_date: date | None = None
     comment: str | None = Field(max_length=1000, default=None)
-
-    @property
-    def values(self) -> dict:
-        """The Past Surgical History command's field values."""
-        return {
-            "past_surgical_history": self.past_surgical_history,
-            "approximate_date": (
-                self.approximate_date.isoformat() if self.approximate_date else None
-            ),
-            "comment": self.comment,
-        }

canvas_sdk/commands/commands/perform.py

@@ -10,8 +10,3 @@ class PerformCommand(BaseCommand):
 
     cpt_code: str
     notes: str | None = None
-
-    @property
-    def values(self) -> dict:
-        """The Perform command's field values."""
-        return {"cpt_code": self.cpt_code, "notes": self.notes}

canvas_sdk/commands/commands/plan.py

@@ -9,8 +9,3 @@ class PlanCommand(_BaseCommand):
         commit_required_fields = ("narrative",)
 
     narrative: str = ""
-
-    @property
-    def values(self) -> dict:
-        """The Plan command's field values."""
-        return {"narrative": self.narrative}

canvas_sdk/commands/commands/prescribe.py

@@ -45,18 +45,11 @@ class PrescribeCommand(_BaseCommand):
     @property
     def values(self) -> dict:
         """The Prescribe command's field values."""
-        return {
-            "fdb_code": self.fdb_code,
-            "icd10_codes": self.icd10_codes,
-            "sig": self.sig,
-            "days_supply": self.days_supply,
-            "quantity_to_dispense": (
+        values = super().values
+
+        if self.is_dirty("quantity_to_dispense"):
+            values["quantity_to_dispense"] = (
                 str(Decimal(self.quantity_to_dispense)) if self.quantity_to_dispense else None
-            ),
-            "type_to_dispense": self.type_to_dispense if self.type_to_dispense else None,
-            "refills": self.refills,
-            "substitutions": self.substitutions.value if self.substitutions else None,
-            "pharmacy": self.pharmacy,
-            "prescriber_id": self.prescriber_id,
-            "note_to_pharmacist": self.note_to_pharmacist,
-        }
+            )
+
+        return values

canvas_sdk/commands/commands/questionnaire.py

@@ -14,8 +14,3 @@ class QuestionnaireCommand(_BaseCommand):
         default=None, json_schema_extra={"commands_api_name": "questionnaire"}
     )
     result: str | None = None
-
-    @property
-    def values(self) -> dict:
-        """The Questionnaire command's field values."""
-        return {"questionnaire_id": self.questionnaire_id, "result": self.result}

canvas_sdk/commands/commands/reason_for_visit.py

@@ -47,12 +47,3 @@ class ReasonForVisitCommand(_BaseCommand):
         # the commands api does not include the 'structured' field in the fields response
         command_schema.pop("structured")
         return command_schema
-
-    @property
-    def values(self) -> dict:
-        """The ReasonForVisit command's field values."""
-        return {
-            "structured": self.structured,
-            "coding": str(self.coding) if isinstance(self.coding, UUID) else self.coding,
-            "comment": self.comment,
-        }

canvas_sdk/commands/commands/remove_allergy.py

@@ -16,11 +16,3 @@ class RemoveAllergyCommand(BaseCommand):
         json_schema_extra={"commands_api_name": "allergy"},
     )
     narrative: str | None = None
-
-    @property
-    def values(self) -> dict:
-        """The Remove Allergy command's field values."""
-        return {
-            "allergy_id": self.allergy_id,
-            "narrative": self.narrative,
-        }

canvas_sdk/commands/commands/stop_medication.py

@@ -15,8 +15,3 @@ class StopMedicationCommand(_BaseCommand):
         default=None, json_schema_extra={"commands_api_name": "medication"}
     )
     rationale: str | None = None
-
-    @property
-    def values(self) -> dict:
-        """The StopMedication command's field values."""
-        return {"medication_id": self.medication_id, "rationale": self.rationale}

canvas_sdk/commands/commands/task.py

@@ -39,15 +39,3 @@ class TaskCommand(BaseCommand):
     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

@@ -15,13 +15,3 @@ class UpdateDiagnosisCommand(BaseCommand):
     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

@@ -36,16 +36,3 @@ class UpdateGoalCommand(_BaseCommand):
     achievement_status: AchievementStatus | None = None
     priority: Priority | None = None
     progress: str | None = None
-
-    @property
-    def values(self) -> dict:
-        """The UpdateGoal command's field values."""
-        return {
-            "goal_id": self.goal_id,
-            "due_date": (self.due_date.isoformat() if self.due_date else None),
-            "achievement_status": (
-                self.achievement_status.value if self.achievement_status else None
-            ),
-            "priority": (self.priority.value if self.priority else None),
-            "progress": self.progress,
-        }

canvas_sdk/commands/commands/vitals.py

@@ -52,29 +52,3 @@ class VitalsCommand(BaseCommand):
     respiration_rate: conint(ge=6, le=60) | None = None  # type: ignore[valid-type]
     oxygen_saturation: conint(ge=60, le=100) | None = None  # type: ignore[valid-type]
     note: constr(max_length=150) | None = None  # type: ignore[valid-type]
-
-    @property
-    def values(self) -> dict:
-        """The Vitals command's field values."""
-        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/tests/test_base_command.py

@@ -0,0 +1,81 @@
+import datetime
+import uuid
+from enum import Enum
+
+import pytest
+
+from canvas_sdk.commands.base import _BaseCommand
+
+
+class DummyEnum(Enum):
+    """A dummy enum class for testing purposes."""
+
+    LOW = "low"
+    HIGH = "high"
+
+
+class DummyCommand(_BaseCommand):
+    """A dummy command class for testing purposes."""
+
+    class Meta:
+        key = "dummyCommand"
+
+    # Fields
+    int_field: int = 0
+    str_field: str = ""
+    enum_field: DummyEnum | None = None
+    date_field: datetime.date | None = None
+    uuid_field: uuid.UUID | None = None
+
+
+@pytest.fixture
+def dummy_command_instance() -> DummyCommand:
+    """Fixture to return a mock instance of DummyCommand for testing."""
+    cmd = DummyCommand(int_field=10, str_field="hello")
+    # Set additional fields after instantiation.
+    cmd.enum_field = DummyEnum.HIGH
+    cmd.date_field = datetime.date(2025, 2, 14)
+    cmd.uuid_field = uuid.UUID("12345678-1234-5678-1234-567812345678")
+    # Set note_uuid and command_uuid for effect methods.
+    cmd.note_uuid = "note-123"
+    cmd.command_uuid = "cmd-456"
+    return cmd
+
+
+def test_dirty_keys(dummy_command_instance: DummyCommand) -> None:
+    """Test that the dirty_keys property correctly tracks all fields that are set (via constructor and subsequent assignment)."""
+    keys = set(dummy_command_instance._dirty_keys)
+    expected_keys = {"int_field", "str_field", "enum_field", "date_field", "uuid_field"}
+    assert expected_keys == keys
+
+
+def test_values_transformation(dummy_command_instance: DummyCommand) -> None:
+    """
+    Test that the values property applies type-specific transformations:
+    - Enums are replaced by their .value.
+    - Date/datetime fields are converted to ISO formatted strings.
+    - UUID fields are converted to strings.
+    - Other types are returned as-is.
+    """
+    vals = dummy_command_instance.values
+    assert vals["int_field"] == 10
+    assert vals["str_field"] == "hello"
+    # For enum_field, should return its .value.
+    assert vals["enum_field"] == DummyEnum.HIGH.value
+    # For date_field, should return an ISO string.
+
+    assert (
+        vals["date_field"] == dummy_command_instance.date_field.isoformat()
+        if dummy_command_instance.date_field
+        else None
+    )
+    # For uuid_field, should return a string.
+    assert vals["uuid_field"] == str(dummy_command_instance.uuid_field)
+
+
+def test_constantized_key(dummy_command_instance: DummyCommand) -> None:
+    """
+    Test that constantized_key transforms the Meta.key from 'dummyCommand'
+    into an uppercase, underscore-separated string ('DUMMY_COMMAND').
+    """
+    assert dummy_command_instance.constantized_key() == "DUMMY_COMMAND"

canvas_sdk/effects/launch_modal.py

@@ -16,6 +16,7 @@ class LaunchModalEffect(_BaseEffect):
         DEFAULT_MODAL = "default_modal"
         NEW_WINDOW = "new_window"
         RIGHT_CHART_PANE = "right_chart_pane"
+        RIGHT_CHART_PANE_LARGE = "right_chart_pane_large"
 
     url: str | None = None
     content: str | None = None