canvas 0.1.12__py3-none-any.whl → 0.1.14__py3-none-any.whl

canvas_sdk/base.py

@@ -0,0 +1,45 @@
+from datetime import date, datetime
+from enum import Enum
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict
+from pydantic_core import InitErrorDetails, PydanticCustomError, ValidationError
+
+
+class Model(BaseModel):
+    """A base model that includes validation methods."""
+
+    class Meta:
+        pass
+
+    model_config = ConfigDict(
+        strict=True,
+        revalidate_instances="always",
+        validate_assignment=True,
+        json_encoders={
+            date: lambda v: v.isoformat(),
+            datetime: lambda v: v.isoformat(),
+            Enum: lambda v: v.value,
+        },
+    )
+
+    def _get_effect_method_required_fields(self, method: str) -> tuple[str]:
+        return getattr(self.Meta, f"{method}_required_fields", tuple())
+
+    def _create_error_detail(self, type: str, message: str, value: Any) -> InitErrorDetails:
+        return InitErrorDetails({"type": PydanticCustomError(type, message), "input": value})
+
+    def _get_error_details(self, method: str) -> list[InitErrorDetails]:
+        required_fields = self._get_effect_method_required_fields(method)
+        return [
+            self._create_error_detail(
+                "missing", f"Field '{field}' is required to {method.replace('_', ' ')} a command", v
+            )
+            for field in required_fields
+            if (v := getattr(self, field)) is None
+        ]
+
+    def _validate_before_effect(self, method: str) -> None:
+        self.model_validate(self)
+        if error_details := self._get_error_details(method):
+            raise ValidationError.from_exception_data(self.__class__.__name__, error_details)

canvas_sdk/commands/base.py

@@ -1,29 +1,51 @@
 import json
+import re
 from enum import EnumType
-from typing import get_args
+from typing import Literal, get_args
 
-from pydantic import BaseModel, ConfigDict, model_validator
-from typing_extensions import Self
+from canvas_sdk.base import Model
+from canvas_sdk.effects import Effect, EffectType
 
-from canvas_sdk.effects import Effect
-
-
-class _BaseCommand(BaseModel):
-    model_config = ConfigDict(strict=True, validate_assignment=True)
 
+class _BaseCommand(Model):
     class Meta:
         key = ""
-
-    # todo: update int to str as we should use external identifiers
-    note_id: int | None = None
+        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",
+        )
+
+    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
+    user_id: int | None = None
 
-    @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
+    def _get_effect_method_required_fields(
+        self, method: Literal["originate", "edit", "delete", "commit", "enter_in_error"]
+    ) -> tuple[str]:
+        base_required_fields: tuple = getattr(
+            _BaseCommand.Meta, f"{method}_required_fields", tuple()
+        )
+        command_required_fields = super()._get_effect_method_required_fields(method)
+        return tuple(set(base_required_fields) | set(command_required_fields))
 
     @property
     def values(self) -> dict:
@@ -52,11 +74,12 @@ class _BaseCommand(BaseModel):
     @classmethod
     def command_schema(cls) -> dict:
         """The schema of the command."""
-        base_properties = {"note_id", "command_uuid", "user_id"}
+        base_properties = {"note_uuid", "command_uuid", "user_id"}
         schema = cls.model_json_schema()
+        required_fields: tuple = getattr(cls.Meta, "originate_required_fields", tuple())
         return {
             definition.get("commands_api_name", name): {
-                "required": name in schema["required"],
+                "required": name in required_fields,
                 "type": cls._get_property_type(name),
                 "choices": cls._get_property_choices(name, schema),
             }
@@ -66,23 +89,23 @@ class _BaseCommand(BaseModel):
 
     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,
-            },
-        }
+        self._validate_before_effect("originate")
+        return Effect(
+            type=EffectType.Value(f"ORIGINATE_{self.constantized_key()}_COMMAND"),
+            payload=json.dumps(
+                {
+                    "user": self.user_id,
+                    "note": self.note_uuid,
+                    "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")
+        self._validate_before_effect("edit")
         return {
-            "type": f"EDIT_{self.Meta.key.upper()}_COMMAND",
+            "type": f"EDIT_{self.constantized_key()}_COMMAND",
             "payload": {
                 "user": self.user_id,
                 "command": self.command_uuid,
@@ -92,27 +115,24 @@ class _BaseCommand(BaseModel):
 
     def delete(self) -> Effect:
         """Delete the command."""
-        if not self.command_uuid:
-            raise AttributeError("Command uuid is required to delete a command")
+        self._validate_before_effect("delete")
         return {
-            "type": f"DELETE_{self.Meta.key.upper()}_COMMAND",
+            "type": f"DELETE_{self.constantized_key()}_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")
+        self._validate_before_effect("commit")
         return {
-            "type": f"COMMIT_{self.Meta.key.upper()}_COMMAND",
+            "type": f"COMMIT_{self.constantized_key()}_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")
+        self._validate_before_effect("enter_in_error")
         return {
-            "type": f"ENTER_IN_ERROR_{self.Meta.key.upper()}_COMMAND",
+            "type": f"ENTER_IN_ERROR_{self.constantized_key()}_COMMAND",
             "payload": {"command": self.command_uuid, "user": self.user_id},
         }

canvas_sdk/commands/commands/assess.py

@@ -1,21 +1,25 @@
 from enum import Enum
 
-from canvas_sdk.commands.base import _BaseCommand
 from pydantic import Field
 
+from canvas_sdk.commands.base import _BaseCommand
+
 
 class AssessCommand(_BaseCommand):
     """A class for managing an Assess command within a specific note."""
 
     class Meta:
         key = "assess"
+        originate_required_fields = ("condition_id",)
 
     class Status(Enum):
         IMPROVED = "improved"
         STABLE = "stable"
         DETERIORATED = "deteriorated"
 
-    condition_id: str = Field(json_schema_extra={"commands_api_name": "condition"})
+    condition_id: str | None = Field(
+        default=None, json_schema_extra={"commands_api_name": "condition"}
+    )
     background: str | None = None
     status: Status | None = None
     narrative: str | None = None

canvas_sdk/commands/commands/diagnose.py

@@ -10,8 +10,11 @@ class DiagnoseCommand(_BaseCommand):
 
     class Meta:
         key = "diagnose"
+        originate_required_fields = ("icd10_code",)
 
-    icd10_code: str = Field(json_schema_extra={"commands_api_name": "diagnose"})
+    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
     today_assessment: str | None = None
@@ -29,16 +32,3 @@ class DiagnoseCommand(_BaseCommand):
             ),
             "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

@@ -9,6 +9,7 @@ class GoalCommand(_BaseCommand):
 
     class Meta:
         key = "goal"
+        originate_required_fields = ("goal_statement", "start_date")
 
     class Priority(Enum):
         HIGH = "high-priority"
@@ -26,7 +27,7 @@ class GoalCommand(_BaseCommand):
         NO_PROGRESS = "no-progress"
         NOT_ATTAINABLE = "not-attainable"
 
-    goal_statement: str
+    goal_statement: str | None = None
     start_date: datetime | None = None
     due_date: datetime | None = None
     achievement_status: AchievementStatus | None = None
@@ -39,7 +40,7 @@ class GoalCommand(_BaseCommand):
         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),
+            "due_date": (self.due_date.isoformat() if self.due_date else None),
             "achievement_status": (
                 self.achievement_status.value if self.achievement_status else None
             ),

canvas_sdk/commands/commands/history_present_illness.py

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

canvas_sdk/commands/commands/medication_statement.py

@@ -1,14 +1,18 @@
-from canvas_sdk.commands.base import _BaseCommand
 from pydantic import Field
 
+from canvas_sdk.commands.base import _BaseCommand
+
 
 class MedicationStatementCommand(_BaseCommand):
     """A class for managing a MedicationStatement command within a specific note."""
 
     class Meta:
         key = "medicationStatement"
+        originate_required_fields = ("fdb_code",)
 
-    fdb_code: str = Field(json_schema_extra={"commands_api_name": "medication"})
+    fdb_code: str | None = Field(
+        default=None, json_schema_extra={"commands_api_name": "medication"}
+    )
     sig: str | None = None
 
     @property

canvas_sdk/commands/commands/plan.py

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

canvas_sdk/commands/commands/prescribe.py

@@ -11,23 +11,34 @@ class PrescribeCommand(_BaseCommand):
 
     class Meta:
         key = "prescribe"
+        originate_required_fields = (
+            "fdb_code",
+            "sig",
+            "quantity_to_dispense",
+            "type_to_dispense",
+            "refills",
+            "substitutions",
+            "prescriber_id",
+        )
 
     class Substitutions(Enum):
         ALLOWED = "allowed"
         NOT_ALLOWED = "not_allowed"
 
-    fdb_code: str = Field(json_schema_extra={"commands_api_name": "prescribe"})
+    fdb_code: str | None = Field(default=None, json_schema_extra={"commands_api_name": "prescribe"})
     icd10_codes: list[str] | None = Field(
-        None, json_schema_extra={"commandsd_api_name": "indications"}
+        None, json_schema_extra={"commands_api_name": "indications"}
     )
-    sig: str
+    sig: str | None = None
     days_supply: int | None = None
-    quantity_to_dispense: Decimal
-    type_to_dispense: str
-    refills: int
-    substitutions: Substitutions = Substitutions.ALLOWED  # type: ignore
+    quantity_to_dispense: Decimal | float | int | None = None
+    type_to_dispense: str | None = None
+    refills: int | None = None
+    substitutions: Substitutions | None = None
     pharmacy: str | None = None
-    prescriber_id: str = Field(json_schema_extra={"commands_api_name": "prescriber"})
+    prescriber_id: str | None = Field(
+        default=None, json_schema_extra={"commands_api_name": "prescriber"}
+    )
     note_to_pharmacist: str | None = None
 
     @property
@@ -38,10 +49,12 @@ class PrescribeCommand(_BaseCommand):
             "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,
+            "quantity_to_dispense": (
+                str(Decimal(self.quantity_to_dispense)) if self.quantity_to_dispense else None
+            ),
+            # "type_to_dispense": self.type_to_dispense,
             "refills": self.refills,
-            "substitutions": self.substitutions,
+            "substitutions": self.substitutions.value if self.substitutions else None,
             "pharmacy": self.pharmacy,
             "prescriber_id": self.prescriber_id,
             "note_to_pharmacist": self.note_to_pharmacist,

canvas_sdk/commands/commands/questionnaire.py

@@ -1,14 +1,18 @@
-from canvas_sdk.commands.base import _BaseCommand
 from pydantic import Field
 
+from canvas_sdk.commands.base import _BaseCommand
+
 
 class QuestionnaireCommand(_BaseCommand):
     """A class for managing a Questionnaire command within a specific note."""
 
     class Meta:
         key = "questionnaire"
+        originate_required_fields = ("questionnaire_id",)
 
-    questionnaire_id: str = Field(json_schema_extra={"commands_api_name": "questionnaire"})
+    questionnaire_id: str | None = Field(
+        default=None, json_schema_extra={"commands_api_name": "questionnaire"}
+    )
     result: str | None = None
 
     @property

canvas_sdk/commands/commands/reason_for_visit.py

@@ -1,5 +1,6 @@
-from pydantic import model_validator
-from typing_extensions import Self
+from typing import Literal
+
+from pydantic_core import InitErrorDetails
 
 from canvas_sdk.commands.base import _BaseCommand
 from canvas_sdk.commands.constants import Coding
@@ -16,11 +17,17 @@ class ReasonForVisitCommand(_BaseCommand):
     coding: Coding | None = None
     comment: str | None = None
 
-    @model_validator(mode="after")
-    def _verify_structured_has_a_coding(self) -> Self:
+    def _get_error_details(
+        self, method: Literal["originate", "edit", "delete", "commit", "enter_in_error"]
+    ) -> list[InitErrorDetails]:
+        errors = super()._get_error_details(method)
         if self.structured and not self.coding:
-            raise ValueError("Structured RFV should have a coding.")
-        return self
+            errors.append(
+                self._create_error_detail(
+                    "value", f"Structured RFV should have a coding.", self.coding
+                )
+            )
+        return errors
 
     @classmethod
     def command_schema(cls) -> dict:

canvas_sdk/commands/commands/stop_medication.py

@@ -1,15 +1,19 @@
-from canvas_sdk.commands.base import _BaseCommand
 from pydantic import Field
 
+from canvas_sdk.commands.base import _BaseCommand
+
 
 class StopMedicationCommand(_BaseCommand):
     """A class for managing a StopMedication command within a specific note."""
 
     class Meta:
         key = "stopMedication"
+        originate_required_fields = ("medication_id",)
 
     # 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"})
+    medication_id: str | None = Field(
+        default=None, json_schema_extra={"commands_api_name": "medication"}
+    )
     rationale: str | None = None
 
     @property

canvas_sdk/commands/commands/update_goal.py

@@ -11,6 +11,7 @@ class UpdateGoalCommand(_BaseCommand):
 
     class Meta:
         key = "updateGoal"
+        originate_required_fields = ("goal_id",)
 
     class AchievementStatus(Enum):
         IN_PROGRESS = "in-progress"
@@ -28,7 +29,9 @@ class UpdateGoalCommand(_BaseCommand):
         MEDIUM = "medium-priority"
         LOW = "low-priority"
 
-    goal_id: str = Field(json_schema_extra={"commands_api_name": "goal_statement"})
+    goal_id: str | None = Field(
+        default=None, json_schema_extra={"commands_api_name": "goal_statement"}
+    )
     due_date: datetime | None = None
     achievement_status: AchievementStatus | None = None
     priority: Priority | None = None

canvas_sdk/commands/tests/test_utils.py

@@ -22,6 +22,17 @@ from canvas_sdk.commands import (
 from canvas_sdk.commands.constants import Coding
 
 
+class MaskedValue:
+    def __init__(self, value):
+        self.value = value
+
+    def __repr__(self) -> str:
+        return "MaskedValue(********)"
+
+    def __str___(self) -> str:
+        return "*******"
+
+
 def get_field_type_unformatted(field_props: dict[str, Any]) -> str:
     if t := field_props.get("type"):
         return field_props.get("format") or t
@@ -77,35 +88,7 @@ def fake(
         return random.choice([e for e in getattr(Command, t)])
 
 
-def raises_missing_error(
-    base: dict,
-    Command: (
-        AssessCommand
-        | DiagnoseCommand
-        | GoalCommand
-        | HistoryOfPresentIllnessCommand
-        | MedicationStatementCommand
-        | PlanCommand
-        | PrescribeCommand
-        | QuestionnaireCommand
-        | ReasonForVisitCommand
-        | StopMedicationCommand
-    ),
-    field: str,
-) -> None:
-    err_kwargs = base.copy()
-    err_kwargs.pop(field)
-    with pytest.raises(ValidationError) as e:
-        Command(**err_kwargs)
-    err_msg = repr(e.value)
-    assert (
-        f"1 validation error for {Command.__name__}\n{field}\n  Field required [type=missing"
-        in err_msg
-    )
-
-
-def raises_none_error(
-    base: dict,
+def raises_wrong_type_error(
     Command: (
         AssessCommand
         | DiagnoseCommand
@@ -122,21 +105,24 @@ def raises_none_error(
 ) -> None:
     field_props = Command.model_json_schema()["properties"][field]
     field_type = get_field_type(field_props)
+    wrong_field_type = "integer" if field_type == "string" else "string"
 
     with pytest.raises(ValidationError) as e1:
-        err_kwargs = base | {field: None}
+        err_kwargs = {field: fake({"type": wrong_field_type}, Command)}
         Command(**err_kwargs)
     err_msg1 = repr(e1.value)
 
-    valid_kwargs = base | {field: fake(field_props, Command)}
+    valid_kwargs = {field: fake(field_props, Command)}
     cmd = Command(**valid_kwargs)
+    err_value = fake({"type": wrong_field_type}, Command)
     with pytest.raises(ValidationError) as e2:
-        setattr(cmd, field, None)
+        setattr(cmd, field, err_value)
     err_msg2 = repr(e2.value)
 
     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
     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
@@ -148,8 +134,7 @@ def raises_none_error(
         assert f"Input should be a valid {field_type}" in err_msg2
 
 
-def raises_wrong_type_error(
-    base: dict,
+def raises_none_error_for_effect_method(
     Command: (
         AssessCommand
         | DiagnoseCommand
@@ -162,34 +147,16 @@ def raises_wrong_type_error(
         | ReasonForVisitCommand
         | StopMedicationCommand
     ),
-    field: str,
+    method: str,
 ) -> None:
-    field_props = Command.model_json_schema()["properties"][field]
-    field_type = get_field_type(field_props)
-    wrong_field_type = "integer" if field_type == "string" else "string"
-
-    with pytest.raises(ValidationError) as e1:
-        err_kwargs = base | {field: fake({"type": wrong_field_type}, Command)}
-        Command(**err_kwargs)
-    err_msg1 = repr(e1.value)
-
-    valid_kwargs = base | {field: fake(field_props, Command)}
-    cmd = Command(**valid_kwargs)
-    err_value = fake({"type": wrong_field_type}, Command)
-    with pytest.raises(ValidationError) as e2:
-        setattr(cmd, field, err_value)
-    err_msg2 = repr(e2.value)
-
-    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
-    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
-    elif field_type[0].isupper():
-        assert f"Input should be an instance of {Command.__name__}.{field_type}" in err_msg1
-        assert f"Input should be an instance of {Command.__name__}.{field_type}" in err_msg2
-    else:
-        assert f"Input should be a valid {field_type}" in err_msg1
-        assert f"Input should be a valid {field_type}" in err_msg2
+    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:
+        assert (
+            f"Field '{f}' is required to {method.replace('_', ' ')} a command [type=missing, input_value=None, input_type=NoneType]"
+            in e_msg
+        )