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

{generated → canvas_generated}/services/plugin_runner_pb2_grpc.py

@@ -2,8 +2,8 @@
 """Client and server classes corresponding to protobuf-defined services."""
 import grpc
 
-from generated.messages import events_pb2 as generated_dot_messages_dot_events__pb2
-from generated.messages import plugins_pb2 as generated_dot_messages_dot_plugins__pb2
+from canvas_generated.messages import events_pb2 as canvas__generated_dot_messages_dot_events__pb2
+from canvas_generated.messages import plugins_pb2 as canvas__generated_dot_messages_dot_plugins__pb2
 
 
 class PluginRunnerStub(object):
@@ -17,13 +17,13 @@ class PluginRunnerStub(object):
         """
         self.HandleEvent = channel.unary_stream(
                 '/canvas.PluginRunner/HandleEvent',
-                request_serializer=generated_dot_messages_dot_events__pb2.Event.SerializeToString,
-                response_deserializer=generated_dot_messages_dot_events__pb2.EventResponse.FromString,
+                request_serializer=canvas__generated_dot_messages_dot_events__pb2.Event.SerializeToString,
+                response_deserializer=canvas__generated_dot_messages_dot_events__pb2.EventResponse.FromString,
                 )
         self.ReloadPlugins = channel.unary_stream(
                 '/canvas.PluginRunner/ReloadPlugins',
-                request_serializer=generated_dot_messages_dot_plugins__pb2.ReloadPluginsRequest.SerializeToString,
-                response_deserializer=generated_dot_messages_dot_plugins__pb2.ReloadPluginsResponse.FromString,
+                request_serializer=canvas__generated_dot_messages_dot_plugins__pb2.ReloadPluginsRequest.SerializeToString,
+                response_deserializer=canvas__generated_dot_messages_dot_plugins__pb2.ReloadPluginsResponse.FromString,
                 )
 
 
@@ -47,13 +47,13 @@ def add_PluginRunnerServicer_to_server(servicer, server):
     rpc_method_handlers = {
             'HandleEvent': grpc.unary_stream_rpc_method_handler(
                     servicer.HandleEvent,
-                    request_deserializer=generated_dot_messages_dot_events__pb2.Event.FromString,
-                    response_serializer=generated_dot_messages_dot_events__pb2.EventResponse.SerializeToString,
+                    request_deserializer=canvas__generated_dot_messages_dot_events__pb2.Event.FromString,
+                    response_serializer=canvas__generated_dot_messages_dot_events__pb2.EventResponse.SerializeToString,
             ),
             'ReloadPlugins': grpc.unary_stream_rpc_method_handler(
                     servicer.ReloadPlugins,
-                    request_deserializer=generated_dot_messages_dot_plugins__pb2.ReloadPluginsRequest.FromString,
-                    response_serializer=generated_dot_messages_dot_plugins__pb2.ReloadPluginsResponse.SerializeToString,
+                    request_deserializer=canvas__generated_dot_messages_dot_plugins__pb2.ReloadPluginsRequest.FromString,
+                    response_serializer=canvas__generated_dot_messages_dot_plugins__pb2.ReloadPluginsResponse.SerializeToString,
             ),
     }
     generic_handler = grpc.method_handlers_generic_handler(
@@ -77,8 +77,8 @@ class PluginRunner(object):
             timeout=None,
             metadata=None):
         return grpc.experimental.unary_stream(request, target, '/canvas.PluginRunner/HandleEvent',
-            generated_dot_messages_dot_events__pb2.Event.SerializeToString,
-            generated_dot_messages_dot_events__pb2.EventResponse.FromString,
+            canvas__generated_dot_messages_dot_events__pb2.Event.SerializeToString,
+            canvas__generated_dot_messages_dot_events__pb2.EventResponse.FromString,
             options, channel_credentials,
             insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
 
@@ -94,7 +94,7 @@ class PluginRunner(object):
             timeout=None,
             metadata=None):
         return grpc.experimental.unary_stream(request, target, '/canvas.PluginRunner/ReloadPlugins',
-            generated_dot_messages_dot_plugins__pb2.ReloadPluginsRequest.SerializeToString,
-            generated_dot_messages_dot_plugins__pb2.ReloadPluginsResponse.FromString,
+            canvas__generated_dot_messages_dot_plugins__pb2.ReloadPluginsRequest.SerializeToString,
+            canvas__generated_dot_messages_dot_plugins__pb2.ReloadPluginsResponse.FromString,
             options, channel_credentials,
             insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

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