canvas 0.1.3__py3-none-any.whl → 0.1.5__py3-none-any.whl

canvas_sdk/commands/base.py

@@ -0,0 +1,118 @@
+import json
+from enum import EnumType
+from typing import get_args
+
+from pydantic import BaseModel, ConfigDict, model_validator
+from typing_extensions import Self
+
+from canvas_sdk.effects import Effect
+
+
+class _BaseCommand(BaseModel):
+    model_config = ConfigDict(strict=True, validate_assignment=True)
+
+    class Meta:
+        key = ""
+
+    # todo: update int to str as we should use external identifiers
+    note_id: int | None = None
+    command_uuid: str | None = None
+    user_id: int
+
+    @model_validator(mode="after")
+    def _verify_has_note_id_or_command_id(self) -> Self:
+        if not self.note_id and not self.command_uuid:
+            raise ValueError("Command should have either a note_id or a command_uuid.")
+        return self
+
+    @property
+    def values(self) -> dict:
+        return {}
+
+    @classmethod
+    def _get_property_choices(cls, name: str, schema: dict) -> list[dict] | None:
+        definition = schema.get("properties", {}).get(name, {})
+        if not (choice_ref := next((a.get("$ref") for a in definition.get("anyOf", [])), None)):
+            return None
+        choice_key = choice_ref.split("#/$defs/")[-1]
+        return schema.get("$defs", {}).get(choice_key, {}).get("enum")
+
+    @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]
+
+        if type(annotation) is EnumType:
+            return str
+
+        return annotation
+
+    @classmethod
+    def command_schema(cls) -> dict:
+        """The schema of the command."""
+        base_properties = {"note_id", "command_uuid", "user_id"}
+        schema = cls.model_json_schema()
+        return {
+            definition.get("commands_api_name", name): {
+                "required": name in schema["required"],
+                "type": cls._get_property_type(name),
+                "choices": cls._get_property_choices(name, schema),
+            }
+            for name, definition in schema["properties"].items()
+            if name not in base_properties
+        }
+
+    def originate(self) -> Effect:
+        """Originate a new command in the note body."""
+        if not self.note_id:
+            raise AttributeError("Note id is required to originate a command")
+        return {
+            "type": f"ADD_{self.Meta.key.upper()}_COMMAND",
+            "payload": {
+                "user": self.user_id,
+                "note": self.note_id,
+                "data": self.values,
+            },
+        }
+
+    def edit(self) -> Effect:
+        """Edit the command."""
+        if not self.command_uuid:
+            raise AttributeError("Command uuid is required to edit a command")
+        return {
+            "type": f"EDIT_{self.Meta.key.upper()}_COMMAND",
+            "payload": {
+                "user": self.user_id,
+                "command": self.command_uuid,
+                "data": self.values,
+            },
+        }
+
+    def delete(self) -> Effect:
+        """Delete the command."""
+        if not self.command_uuid:
+            raise AttributeError("Command uuid is required to delete a command")
+        return {
+            "type": f"DELETE_{self.Meta.key.upper()}_COMMAND",
+            "payload": {"command": self.command_uuid, "user": self.user_id},
+        }
+
+    def commit(self) -> Effect:
+        """Commit the command."""
+        if not self.command_uuid:
+            raise AttributeError("Command uuid is required to commit a command")
+        return {
+            "type": f"COMMIT_{self.Meta.key.upper()}_COMMAND",
+            "payload": {"command": self.command_uuid, "user": self.user_id},
+        }
+
+    def enter_in_error(self) -> Effect:
+        """Mark the command as entered-in-error."""
+        if not self.command_uuid:
+            raise AttributeError("Command uuid is required to enter in error a command")
+        return {
+            "type": f"ENTER_IN_ERROR_{self.Meta.key.upper()}_COMMAND",
+            "payload": {"command": self.command_uuid, "user": self.user_id},
+        }

canvas_sdk/commands/commands/assess.py

@@ -0,0 +1,48 @@
+from enum import Enum
+
+from canvas_sdk.commands.base import _BaseCommand
+from pydantic import Field
+
+
+class AssessCommand(_BaseCommand):
+    """A class for managing an Assess command within a specific note."""
+
+    class Meta:
+        key = "assess"
+
+    class Status(Enum):
+        IMPROVED = "improved"
+        STABLE = "stable"
+        DETERIORATED = "deteriorated"
+
+    condition_id: str = Field(json_schema_extra={"commands_api_name": "condition"})
+    background: str | None = None
+    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?
+
+# idea1:
+# create a class attribute 'pre_validate_condition': bool
+#      True: before doing any actions against the home-app instance, will first check
+#            if its an active condition for that patient, and it not then logs a message
+#            and doesn't do the action. can even create a cache so that we dont always
+#            have to keep asking home-app for every patient
+#      False: still tries to do it but will run up against whatever home-app barriers
+#             we have against actions like that (if those dont already exist, then
+#             definitely create them!)
+
+
+# idea2:
+# validator that checks that condition.patient is the same as note.patient

canvas_sdk/commands/commands/diagnose.py

@@ -0,0 +1,44 @@
+from datetime import datetime
+
+from pydantic import Field
+
+from canvas_sdk.commands.base import _BaseCommand
+
+
+class DiagnoseCommand(_BaseCommand):
+    """A class for managing a Diagnose command within a specific note."""
+
+    class Meta:
+        key = "diagnose"
+
+    icd10_code: str = Field(json_schema_extra={"commands_api_name": "diagnose"})
+    background: str | None = None
+    approximate_date_of_onset: datetime | 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,
+        }
+
+
+# how do we make sure icd10_code is a valid code?
+
+# idea1:
+# create an auto-generated enum class of all possible icd10s, then type the field as that enum
+# will require releasing a new version with the new codes every year, and devs will need to update
+# to make sure they have the latest version to get the right set of codes.
+
+# idea2:
+# see if we can get ValueSets to play nicely with pydantic
+
+# idea3: runtime warning after pinging ontologies

canvas_sdk/commands/commands/goal.py

@@ -0,0 +1,48 @@
+from datetime import datetime
+from enum import Enum
+
+from canvas_sdk.commands.base import _BaseCommand
+
+
+class GoalCommand(_BaseCommand):
+    """A class for managing a Goal command within a specific note."""
+
+    class Meta:
+        key = "goal"
+
+    class Priority(Enum):
+        HIGH = "high-priority"
+        MEDIUM = "medium-priority"
+        LOW = "low-priority"
+
+    class AchievementStatus(Enum):
+        IN_PROGRESS = "in-progress"
+        IMPROVING = "improving"
+        WORSENING = "worsening"
+        NO_CHANGE = "no-change"
+        ACHIEVED = "achieved"
+        SUSTAINING = "sustaining"
+        NOT_ACHIEVED = "not-achieved"
+        NO_PROGRESS = "no-progress"
+        NOT_ATTAINABLE = "not-attainable"
+
+    goal_statement: str
+    start_date: datetime | None = None
+    due_date: datetime | None = None
+    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.start_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

@@ -0,0 +1,15 @@
+from canvas_sdk.commands.base import _BaseCommand
+
+
+class HistoryOfPresentIllnessCommand(_BaseCommand):
+    """A class for managing a HPI command within a specific note."""
+
+    class Meta:
+        key = "hpi"
+
+    narrative: str
+
+    @property
+    def values(self) -> dict:
+        """The HPI command's field values."""
+        return {"narrative": self.narrative}

canvas_sdk/commands/commands/medication_statement.py

@@ -0,0 +1,28 @@
+from canvas_sdk.commands.base import _BaseCommand
+from pydantic import Field
+
+
+class MedicationStatementCommand(_BaseCommand):
+    """A class for managing a MedicationStatement command within a specific note."""
+
+    class Meta:
+        key = "medicationStatement"
+
+    fdb_code: str = Field(json_schema_extra={"commands_api_name": "medication"})
+    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?
+
+# idea1:
+# create an auto-generated enum class of all possible fdbs, then type the field as that enum
+# will require releasing a new version with the new codes every year, and devs will need to update
+# to make sure they have the latest version to get the right set of codes.
+
+# idea2:
+# see if we can get ValueSets to play nicely with pydantic

canvas_sdk/commands/commands/plan.py

@@ -0,0 +1,15 @@
+from canvas_sdk.commands.base import _BaseCommand
+
+
+class PlanCommand(_BaseCommand):
+    """A class for managing a Plan command within a specific note."""
+
+    class Meta:
+        key = "plan"
+
+    narrative: str
+
+    @property
+    def values(self) -> dict:
+        """The Plan command's field values."""
+        return {"narrative": self.narrative}

canvas_sdk/commands/commands/prescribe.py

@@ -0,0 +1,48 @@
+from decimal import Decimal
+from enum import Enum
+
+from pydantic import Field
+
+from canvas_sdk.commands.base import _BaseCommand
+
+
+class PrescribeCommand(_BaseCommand):
+    """A class for managing a Prescribe command within a specific note."""
+
+    class Meta:
+        key = "prescribe"
+
+    class Substitutions(Enum):
+        ALLOWED = "allowed"
+        NOT_ALLOWED = "not_allowed"
+
+    fdb_code: str = Field(json_schema_extra={"commands_api_name": "prescribe"})
+    icd10_codes: list[str] | None = Field(
+        None, json_schema_extra={"commandsd_api_name": "indications"}
+    )
+    sig: str
+    days_supply: int | None = None
+    quantity_to_dispense: Decimal
+    type_to_dispense: str
+    refills: int
+    substitutions: Substitutions = Substitutions.ALLOWED  # type: ignore
+    pharmacy: str | None = None
+    prescriber_id: str = Field(json_schema_extra={"commands_api_name": "prescriber"})
+    note_to_pharmacist: str | None = None
+
+    @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": self.quantity_to_dispense,
+            "type_to_dispense": self.type_to_dispense,
+            "refills": self.refills,
+            "substitutions": self.substitutions,
+            "pharmacy": self.pharmacy,
+            "prescriber_id": self.prescriber_id,
+            "note_to_pharmacist": self.note_to_pharmacist,
+        }

canvas_sdk/commands/commands/questionnaire.py

@@ -0,0 +1,17 @@
+from canvas_sdk.commands.base import _BaseCommand
+from pydantic import Field
+
+
+class QuestionnaireCommand(_BaseCommand):
+    """A class for managing a Questionnaire command within a specific note."""
+
+    class Meta:
+        key = "questionnaire"
+
+    questionnaire_id: str = Field(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

@@ -0,0 +1,36 @@
+from pydantic import model_validator
+from typing_extensions import Self
+
+from canvas_sdk.commands.base import _BaseCommand
+from canvas_sdk.commands.constants import Coding
+
+
+class ReasonForVisitCommand(_BaseCommand):
+    """A class for managing a ReasonForVisit command within a specific note."""
+
+    class Meta:
+        key = "reasonForVisit"
+
+    structured: bool = False
+    # how do we make sure that coding is a valid rfv coding from their home-app?
+    coding: Coding | None = None
+    comment: str | None = None
+
+    @model_validator(mode="after")
+    def _verify_structured_has_a_coding(self) -> Self:
+        if self.structured and not self.coding:
+            raise ValueError("Structured RFV should have a coding.")
+        return self
+
+    @classmethod
+    def command_schema(cls) -> dict:
+        """The schema of the command."""
+        command_schema = super().command_schema()
+        # 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": self.coding, "comment": self.comment}

canvas_sdk/commands/commands/stop_medication.py

@@ -0,0 +1,18 @@
+from canvas_sdk.commands.base import _BaseCommand
+from pydantic import Field
+
+
+class StopMedicationCommand(_BaseCommand):
+    """A class for managing a StopMedication command within a specific note."""
+
+    class Meta:
+        key = "stopMedication"
+
+    # how do we make sure this is a valid medication_id for the patient?
+    medication_id: str = Field(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/update_goal.py

@@ -0,0 +1,48 @@
+from datetime import datetime
+from enum import Enum
+
+from pydantic import Field
+
+from canvas_sdk.commands.base import _BaseCommand
+
+
+class UpdateGoalCommand(_BaseCommand):
+    """A class for managing an UpdateGoal command within a specific note."""
+
+    class Meta:
+        key = "updateGoal"
+
+    class AchievementStatus(Enum):
+        IN_PROGRESS = "in-progress"
+        IMPROVING = "improving"
+        WORSENING = "worsening"
+        NO_CHANGE = "no-change"
+        ACHIEVED = "achieved"
+        SUSTAINING = "sustaining"
+        NOT_ACHIEVED = "not-achieved"
+        NO_PROGRESS = "no-progress"
+        NOT_ATTAINABLE = "not-attainable"
+
+    class Priority(Enum):
+        HIGH = "high-priority"
+        MEDIUM = "medium-priority"
+        LOW = "low-priority"
+
+    goal_id: str = Field(json_schema_extra={"commands_api_name": "goal_statement"})
+    due_date: datetime | None = None
+    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/constants.py

@@ -0,0 +1,9 @@
+from typing_extensions import NotRequired, TypedDict
+
+
+class Coding(TypedDict):
+    """Coding object in Canvas."""
+
+    system: str
+    code: str
+    display: NotRequired[str]