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

canvas_sdk/__init__.py

@@ -0,0 +1,7 @@
+import os
+
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "settings")
+
+import django
+
+django.setup()

canvas_sdk/base.py

@@ -23,7 +23,7 @@ class Model(BaseModel):
         },
     )
 
-    def _get_effect_method_required_fields(self, method: str) -> tuple[str]:
+    def _get_effect_method_required_fields(self, method: str) -> tuple[str] | tuple:
         return getattr(self.Meta, f"{method}_required_fields", tuple())
 
     def _create_error_detail(self, type: str, message: str, value: Any) -> InitErrorDetails:
@@ -31,9 +31,13 @@ class Model(BaseModel):
 
     def _get_error_details(self, method: str) -> list[InitErrorDetails]:
         required_fields = self._get_effect_method_required_fields(method)
+        class_name = self.__repr_name__()
+        class_name_article = "an" if class_name.startswith(("A", "E", "I", "O", "U")) else "a"
         return [
             self._create_error_detail(
-                "missing", f"Field '{field}' is required to {method.replace('_', ' ')} a command", v
+                "missing",
+                f"Field '{field}' is required to {method.replace('_', ' ')} {class_name_article} {class_name}",
+                v,
             )
             for field in required_fields
             if (v := getattr(self, field)) is None

canvas_sdk/commands/__init__.py

@@ -1,27 +1,53 @@
+from canvas_sdk.commands.commands.allergy import AllergyCommand
 from canvas_sdk.commands.commands.assess import AssessCommand
+from canvas_sdk.commands.commands.close_goal import CloseGoalCommand
 from canvas_sdk.commands.commands.diagnose import DiagnoseCommand
+from canvas_sdk.commands.commands.family_history import FamilyHistoryCommand
 from canvas_sdk.commands.commands.goal import GoalCommand
 from canvas_sdk.commands.commands.history_present_illness import (
     HistoryOfPresentIllnessCommand,
 )
+from canvas_sdk.commands.commands.instruct import InstructCommand
+from canvas_sdk.commands.commands.lab_order import LabOrderCommand
+from canvas_sdk.commands.commands.medical_history import MedicalHistoryCommand
 from canvas_sdk.commands.commands.medication_statement import MedicationStatementCommand
+from canvas_sdk.commands.commands.past_surgical_history import PastSurgicalHistoryCommand
+from canvas_sdk.commands.commands.perform import PerformCommand
 from canvas_sdk.commands.commands.plan import PlanCommand
 from canvas_sdk.commands.commands.prescribe import PrescribeCommand
 from canvas_sdk.commands.commands.questionnaire import QuestionnaireCommand
 from canvas_sdk.commands.commands.reason_for_visit import ReasonForVisitCommand
+from canvas_sdk.commands.commands.refill import RefillCommand
+from canvas_sdk.commands.commands.remove_allergy import RemoveAllergyCommand
 from canvas_sdk.commands.commands.stop_medication import StopMedicationCommand
+from canvas_sdk.commands.commands.task import TaskCommand
+from canvas_sdk.commands.commands.update_diagnosis import UpdateDiagnosisCommand
 from canvas_sdk.commands.commands.update_goal import UpdateGoalCommand
+from canvas_sdk.commands.commands.vitals import VitalsCommand
 
 __all__ = (
+    "AllergyCommand",
     "AssessCommand",
+    "CloseGoalCommand",
     "DiagnoseCommand",
+    "FamilyHistoryCommand",
     "GoalCommand",
     "HistoryOfPresentIllnessCommand",
+    "InstructCommand",
+    "LabOrderCommand",
+    "MedicalHistoryCommand",
     "MedicationStatementCommand",
+    "PastSurgicalHistoryCommand",
+    "PerformCommand",
     "PlanCommand",
     "PrescribeCommand",
     "QuestionnaireCommand",
     "ReasonForVisitCommand",
+    "RefillCommand",
+    "RemoveAllergyCommand",
     "StopMedicationCommand",
+    "TaskCommand",
+    "UpdateDiagnosisCommand",
     "UpdateGoalCommand",
+    "VitalsCommand",
 )

canvas_sdk/commands/base.py

@@ -1,42 +1,29 @@
 import json
 import re
 from enum import EnumType
-from typing import Literal, get_args
+from types import NoneType, UnionType
+from typing import Literal, get_args, get_origin, Union
 
 from canvas_sdk.base import Model
+from canvas_sdk.commands.constants import Coding
 from canvas_sdk.effects import Effect, EffectType
+from canvas_sdk.effects.protocol_card import Recommendation
 
 
 class _BaseCommand(Model):
     class Meta:
         key = ""
-        originate_required_fields = (
-            "user_id",
-            "note_uuid",
-        )
-        edit_required_fields = (
-            "user_id",
-            "command_uuid",
-        )
-        delete_required_fields = (
-            "user_id",
-            "command_uuid",
-        )
-        commit_required_fields = (
-            "user_id",
-            "command_uuid",
-        )
-        enter_in_error_required_fields = (
-            "user_id",
-            "command_uuid",
-        )
+        originate_required_fields = ("note_uuid",)
+        edit_required_fields = ("command_uuid",)
+        delete_required_fields = ("command_uuid",)
+        commit_required_fields = ("command_uuid",)
+        enter_in_error_required_fields = ("command_uuid",)
 
     def constantized_key(self) -> str:
         return re.sub(r"(?<!^)(?=[A-Z])", "_", self.Meta.key).upper()
 
     note_uuid: str | None = None
     command_uuid: str | None = None
-    user_id: int | None = None
 
     def _get_effect_method_required_fields(
         self, method: Literal["originate", "edit", "delete", "commit", "enter_in_error"]
@@ -51,6 +38,11 @@ class _BaseCommand(Model):
     def values(self) -> dict:
         return {}
 
+    @property
+    def coding_filter(self) -> Coding | None:
+        """The coding filter used for command insertion in protocol cards."""
+        return None
+
     @classmethod
     def _get_property_choices(cls, name: str, schema: dict) -> list[dict] | None:
         definition = schema.get("properties", {}).get(name, {})
@@ -62,9 +54,15 @@ class _BaseCommand(Model):
     @classmethod
     def _get_property_type(cls, name: str) -> type:
         annotation = cls.model_fields[name].annotation
-        if annotation_args := get_args(annotation):
-            # if its a union, take the first one (which is not None)
-            annotation = annotation_args[0]
+        origin = get_origin(annotation)
+
+        # Handle Union types
+        if origin is UnionType or origin is Union:
+            annotation_args = get_args(annotation)
+            # Filter out NoneType and take the first valid type
+            annotation = next(
+                (arg for arg in annotation_args if arg is not NoneType), annotation_args[0]
+            )
 
         if type(annotation) is EnumType:
             return str
@@ -74,9 +72,9 @@ class _BaseCommand(Model):
     @classmethod
     def command_schema(cls) -> dict:
         """The schema of the command."""
-        base_properties = {"note_uuid", "command_uuid", "user_id"}
+        base_properties = {"note_uuid", "command_uuid"}
         schema = cls.model_json_schema()
-        required_fields: tuple = getattr(cls.Meta, "originate_required_fields", tuple())
+        required_fields: tuple = getattr(cls.Meta, "commit_required_fields", tuple())
         return {
             definition.get("commands_api_name", name): {
                 "required": name in required_fields,
@@ -94,7 +92,6 @@ class _BaseCommand(Model):
             type=EffectType.Value(f"ORIGINATE_{self.constantized_key()}_COMMAND"),
             payload=json.dumps(
                 {
-                    "user": self.user_id,
                     "note": self.note_uuid,
                     "data": self.values,
                 }
@@ -107,7 +104,6 @@ class _BaseCommand(Model):
         return {
             "type": f"EDIT_{self.constantized_key()}_COMMAND",
             "payload": {
-                "user": self.user_id,
                 "command": self.command_uuid,
                 "data": self.values,
             },
@@ -118,7 +114,7 @@ class _BaseCommand(Model):
         self._validate_before_effect("delete")
         return {
             "type": f"DELETE_{self.constantized_key()}_COMMAND",
-            "payload": {"command": self.command_uuid, "user": self.user_id},
+            "payload": {"command": self.command_uuid},
         }
 
     def commit(self) -> Effect:
@@ -126,7 +122,7 @@ class _BaseCommand(Model):
         self._validate_before_effect("commit")
         return {
             "type": f"COMMIT_{self.constantized_key()}_COMMAND",
-            "payload": {"command": self.command_uuid, "user": self.user_id},
+            "payload": {"command": self.command_uuid},
         }
 
     def enter_in_error(self) -> Effect:
@@ -134,5 +130,12 @@ class _BaseCommand(Model):
         self._validate_before_effect("enter_in_error")
         return {
             "type": f"ENTER_IN_ERROR_{self.constantized_key()}_COMMAND",
-            "payload": {"command": self.command_uuid, "user": self.user_id},
+            "payload": {"command": self.command_uuid},
         }
+
+    def recommend(self, title: str = "", button: str | None = None) -> Recommendation:
+        """Returns a command recommendation to be inserted via Protocol Card."""
+        if button is None:
+            button = self.constantized_key().lower().replace("_", " ")
+        command = self.Meta.key.lower()
+        return Recommendation(title=title, button=button, command=command, context=self.values)

canvas_sdk/commands/commands/allergy.py

@@ -0,0 +1,49 @@
+from datetime import date
+from enum import Enum, IntEnum
+
+from typing_extensions import TypedDict
+
+from canvas_sdk.commands.base import _BaseCommand as BaseCommand
+
+
+class AllergenType(IntEnum):
+    ALLERGEN_GROUP = 1
+    MEDICATION = 2
+    INGREDIENT = 6
+
+
+class Allergen(TypedDict):
+    """A TypedDict representing an allergen."""
+
+    concept_id: int
+    concept_type: AllergenType
+
+
+class AllergyCommand(BaseCommand):
+    """A class for managing an Allergy command within a specific note."""
+
+    class Meta:
+        key = "allergy"
+        commit_required_fields = ("allergy",)
+
+    class Severity(Enum):
+        MILD = "mild"
+        MODERATE = "moderate"
+        SEVERE = "severe"
+
+    allergy: Allergen | None = None
+    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

@@ -10,7 +10,7 @@ class AssessCommand(_BaseCommand):
 
     class Meta:
         key = "assess"
-        originate_required_fields = ("condition_id",)
+        commit_required_fields = ("condition_id",)
 
     class Status(Enum):
         IMPROVED = "improved"

canvas_sdk/commands/commands/close_goal.py

@@ -0,0 +1,22 @@
+from canvas_sdk.commands.base import _BaseCommand as BaseCommand
+from canvas_sdk.commands.commands.goal import GoalCommand
+
+
+class CloseGoalCommand(BaseCommand):
+    class Meta:
+        key = "closeGoal"
+        commit_required_fields = ("goal_id",)
+
+    goal_id: int | None = None
+    achievement_status: GoalCommand.AchievementStatus | None = None
+    progress: str | None = None
+
+    @property
+    def values(self) -> dict:
+        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

@@ -1,4 +1,4 @@
-from datetime import datetime
+from datetime import date
 
 from pydantic import Field
 
@@ -10,13 +10,13 @@ class DiagnoseCommand(_BaseCommand):
 
     class Meta:
         key = "diagnose"
-        originate_required_fields = ("icd10_code",)
+        commit_required_fields = ("icd10_code",)
 
     icd10_code: str | None = Field(
         default=None, json_schema_extra={"commands_api_name": "diagnose"}
     )
     background: str | None = None
-    approximate_date_of_onset: datetime | None = None
+    approximate_date_of_onset: date | None = None
     today_assessment: str | None = None
 
     @property

canvas_sdk/commands/commands/family_history.py

@@ -0,0 +1,18 @@
+from canvas_sdk.commands.base import _BaseCommand as BaseCommand
+
+
+class FamilyHistoryCommand(BaseCommand):
+    """A class for managing a Family History command within a specific note."""
+
+    class Meta:
+        key = "familyHistory"
+        commit_required_fields = ("family_history",)
+
+    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/goal.py

@@ -9,7 +9,7 @@ class GoalCommand(_BaseCommand):
 
     class Meta:
         key = "goal"
-        originate_required_fields = ("goal_statement", "start_date")
+        commit_required_fields = ("goal_statement", "start_date")
 
     class Priority(Enum):
         HIGH = "high-priority"
@@ -27,8 +27,8 @@ class GoalCommand(_BaseCommand):
         NO_PROGRESS = "no-progress"
         NOT_ATTAINABLE = "not-attainable"
 
-    goal_statement: str | None = None
-    start_date: datetime | None = None
+    goal_statement: str = ""
+    start_date: datetime = datetime.now()
     due_date: datetime | None = None
     achievement_status: AchievementStatus | None = None
     priority: Priority | None = None

canvas_sdk/commands/commands/history_present_illness.py

@@ -6,7 +6,7 @@ class HistoryOfPresentIllnessCommand(_BaseCommand):
 
     class Meta:
         key = "hpi"
-        originate_required_fields = ("narrative",)
+        commit_required_fields = ("narrative",)
 
     narrative: str | None = None
 

canvas_sdk/commands/commands/instruct.py

@@ -0,0 +1,17 @@
+from canvas_sdk.commands.base import _BaseCommand as BaseCommand
+
+
+class InstructCommand(BaseCommand):
+    """A class for managing an Instruct command within a specific note."""
+
+    class Meta:
+        key = "instruct"
+        commit_required_fields = ("instruction",)
+
+    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

@@ -0,0 +1,33 @@
+from canvas_sdk.commands.base import _BaseCommand as BaseCommand
+
+
+class LabOrderCommand(BaseCommand):
+    """A class for managing a Lab Order command within a specific note."""
+
+    class Meta:
+        key = "labOrder"
+        commit_required_fields = (
+            "lab_partner",
+            "tests_order_codes",
+            "ordering_provider",
+            "diagnosis_codes",
+        )
+
+    lab_partner: str | None = None
+    tests_order_codes: list[str] = []
+    ordering_provider_key: str | None = None
+    diagnosis_codes: list[str] = []
+    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,
+        }

canvas_sdk/commands/commands/medical_history.py

@@ -0,0 +1,34 @@
+from datetime import date
+
+from pydantic import Field
+
+from canvas_sdk.commands.base import _BaseCommand as BaseCommand
+
+
+class MedicalHistoryCommand(BaseCommand):
+    """A class for managing a Medical History command within a specific note."""
+
+    class Meta:
+        key = "medicalHistory"
+        commit_required_fields = ("past_medical_history",)
+
+    past_medical_history: str | None = None
+    approximate_start_date: date | None = None
+    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

@@ -8,7 +8,7 @@ class MedicationStatementCommand(_BaseCommand):
 
     class Meta:
         key = "medicationStatement"
-        originate_required_fields = ("fdb_code",)
+        commit_required_fields = ("fdb_code",)
 
     fdb_code: str | None = Field(
         default=None, json_schema_extra={"commands_api_name": "medication"}

canvas_sdk/commands/commands/past_surgical_history.py

@@ -0,0 +1,28 @@
+from datetime import date
+
+from pydantic import Field
+
+from canvas_sdk.commands.base import _BaseCommand as BaseCommand
+
+
+class PastSurgicalHistoryCommand(BaseCommand):
+    """A class for managing a Past Surgical History command within a specific note."""
+
+    class Meta:
+        key = "surgicalHistory"
+        commit_required_fields = ("past_surgical_history",)
+
+    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

@@ -0,0 +1,17 @@
+from canvas_sdk.commands.base import _BaseCommand as BaseCommand
+
+
+class PerformCommand(BaseCommand):
+    """A class for managing a Perform command within a specific note."""
+
+    class Meta:
+        key = "perform"
+        commit_required_fields = ("cpt_code",)
+
+    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

@@ -6,9 +6,9 @@ class PlanCommand(_BaseCommand):
 
     class Meta:
         key = "plan"
-        originate_required_fields = ("narrative",)
+        commit_required_fields = ("narrative",)
 
-    narrative: str | None = None
+    narrative: str = ""
 
     @property
     def values(self) -> dict:

canvas_sdk/commands/commands/prescribe.py

@@ -1,9 +1,12 @@
+from dataclasses import dataclass
 from decimal import Decimal
 from enum import Enum
+from typing import TypeVar
 
-from pydantic import Field
+from pydantic import Field, conlist
 
 from canvas_sdk.commands.base import _BaseCommand
+from canvas_sdk.commands.constants import ClinicalQuantity
 
 
 class PrescribeCommand(_BaseCommand):
@@ -11,7 +14,7 @@ class PrescribeCommand(_BaseCommand):
 
     class Meta:
         key = "prescribe"
-        originate_required_fields = (
+        commit_required_fields = (
             "fdb_code",
             "sig",
             "quantity_to_dispense",
@@ -26,13 +29,13 @@ class PrescribeCommand(_BaseCommand):
         NOT_ALLOWED = "not_allowed"
 
     fdb_code: str | None = Field(default=None, json_schema_extra={"commands_api_name": "prescribe"})
-    icd10_codes: list[str] | None = Field(
-        None, json_schema_extra={"commands_api_name": "indications"}
+    icd10_codes: conlist(str, max_length=2) = Field(
+        [], json_schema_extra={"commands_api_name": "indications"}
     )
-    sig: str | None = None
+    sig: str = ""
     days_supply: int | None = None
     quantity_to_dispense: Decimal | float | int | None = None
-    type_to_dispense: str | None = None
+    type_to_dispense: ClinicalQuantity | None = None
     refills: int | None = None
     substitutions: Substitutions | None = None
     pharmacy: str | None = None
@@ -52,7 +55,7 @@ class PrescribeCommand(_BaseCommand):
             "quantity_to_dispense": (
                 str(Decimal(self.quantity_to_dispense)) if self.quantity_to_dispense else None
             ),
-            # "type_to_dispense": self.type_to_dispense,
+            "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,

canvas_sdk/commands/commands/questionnaire.py

@@ -8,7 +8,7 @@ class QuestionnaireCommand(_BaseCommand):
 
     class Meta:
         key = "questionnaire"
-        originate_required_fields = ("questionnaire_id",)
+        commit_required_fields = ("questionnaire_id",)
 
     questionnaire_id: str | None = Field(
         default=None, json_schema_extra={"commands_api_name": "questionnaire"}

canvas_sdk/commands/commands/refill.py

@@ -0,0 +1,16 @@
+from canvas_sdk.commands.commands.prescribe import PrescribeCommand
+
+
+class RefillCommand(PrescribeCommand):
+
+    class Meta:
+        key = "refill"
+        commit_required_fields = (
+            "fdb_code",
+            "sig",
+            "quantity_to_dispense",
+            "type_to_dispense",
+            "refills",
+            "substitutions",
+            "prescriber_id",
+        )

canvas_sdk/commands/commands/remove_allergy.py

@@ -0,0 +1,26 @@
+from pydantic import Field
+
+from canvas_sdk.commands.base import _BaseCommand as BaseCommand
+
+
+class RemoveAllergyCommand(BaseCommand):
+    """A class for managing a Remove Allergy command within a specific note."""
+
+    class Meta:
+        key = "removeAllergy"
+        commit_required_fields = ("allergy_id",)
+
+    allergy_id: str | None = Field(
+        description="The external ID of the allergy to remove.",
+        default=None,
+        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

@@ -8,7 +8,7 @@ class StopMedicationCommand(_BaseCommand):
 
     class Meta:
         key = "stopMedication"
-        originate_required_fields = ("medication_id",)
+        commit_required_fields = ("medication_id",)
 
     # how do we make sure this is a valid medication_id for the patient?
     medication_id: str | None = Field(