canvas 0.34.0__py3-none-any.whl → 0.35.0__py3-none-any.whl

canvas_sdk/commands/commands/task.py

@@ -28,10 +28,6 @@ class TaskCommand(BaseCommand):
 
     class Meta:
         key = "task"
-        commit_required_fields = (
-            "title",
-            "assign_to",
-        )
 
     title: str = ""
     assign_to: TaskAssigner | None = None

canvas_sdk/commands/commands/update_diagnosis.py

@@ -1,3 +1,5 @@
+from pydantic import Field
+
 from canvas_sdk.commands.base import _BaseCommand as BaseCommand
 
 
@@ -6,13 +8,13 @@ class UpdateDiagnosisCommand(BaseCommand):
 
     class Meta:
         key = "updateDiagnosis"
-        commit_required_fields = (
-            "condition_code",
-            "new_condition_code",
-        )
 
-    condition_code: str | None = None
-    new_condition_code: str | None = None
+    condition_code: str | None = Field(
+        default=None, json_schema_extra={"commands_api_name": "condition"}
+    )
+    new_condition_code: str | None = Field(
+        default=None, json_schema_extra={"commands_api_name": "new_condition"}
+    )
     background: str | None = None
     narrative: str | None = None
 

canvas_sdk/commands/commands/update_goal.py

@@ -11,7 +11,6 @@ class UpdateGoalCommand(_BaseCommand):
 
     class Meta:
         key = "updateGoal"
-        commit_required_fields = ("goal_id",)
 
     class AchievementStatus(Enum):
         IN_PROGRESS = "in-progress"

canvas_sdk/commands/commands/vitals.py

@@ -10,7 +10,6 @@ class VitalsCommand(BaseCommand):
 
     class Meta:
         key = "vitals"
-        commit_required_fields = ()
 
     class BodyTemperatureSite(Enum):
         AXILLARY = 0

canvas_sdk/effects/note/__init__.py

@@ -0,0 +1,10 @@
+from canvas_sdk.effects.note.appointment import Appointment, ScheduleEvent
+from canvas_sdk.effects.note.base import AppointmentIdentifier
+from canvas_sdk.effects.note.note import Note
+
+__all__ = __exports__ = (
+    "AppointmentIdentifier",
+    "Note",
+    "Appointment",
+    "ScheduleEvent",
+)

canvas_sdk/effects/note/appointment.py

@@ -0,0 +1,148 @@
+from typing import Any
+from uuid import UUID
+
+from pydantic_core import InitErrorDetails
+
+from canvas_sdk.effects.note.base import AppointmentABC
+from canvas_sdk.v1.data import NoteType, Patient
+from canvas_sdk.v1.data.note import NoteTypeCategories
+
+
+class ScheduleEvent(AppointmentABC):
+    """
+    Effect to create a schedule event.
+
+    Attributes:
+        note_type_id (UUID | str): The ID of the note type.
+        patient_id (str | None): The ID of the patient, if applicable.
+        description (str | None): The description of the schedule event, if applicable.
+    """
+
+    class Meta:
+        effect_type = "SCHEDULE_EVENT"
+
+    note_type_id: UUID | str
+    patient_id: str | None = None
+    description: str | None = None
+
+    def _get_error_details(self, method: Any) -> list[InitErrorDetails]:
+        """
+        Validates the schedule event note type and returns a list of error details if validation fails.
+
+        Args:
+            method (Any): The method being validated.
+
+        Returns:
+            list[InitErrorDetails]: A list of error details for invalid schedule event note types.
+        """
+        errors = super()._get_error_details(method)
+
+        note_type = (
+            NoteType.objects.values("category", "is_patient_required", "allow_custom_title")
+            .filter(id=self.note_type_id)
+            .first()
+        )
+
+        if not note_type:
+            errors.append(
+                self._create_error_detail(
+                    "value",
+                    f"Note type with ID {self.note_type_id} does not exist.",
+                    self.note_type_id,
+                )
+            )
+            return errors
+
+        if note_type["category"] != NoteTypeCategories.SCHEDULE_EVENT:
+            errors.append(
+                self._create_error_detail(
+                    "value",
+                    f"Schedule event note type must be of type: {NoteTypeCategories.SCHEDULE_EVENT}.",
+                    self.note_type_id,
+                )
+            )
+
+        if note_type["is_patient_required"] and not self.patient_id:
+            errors.append(
+                self._create_error_detail(
+                    "value",
+                    "Patient ID is required for this note type.",
+                    self.note_type_id,
+                )
+            )
+
+        if not note_type["allow_custom_title"] and self.description:
+            errors.append(
+                self._create_error_detail(
+                    "value",
+                    "Description is not allowed for this note type.",
+                    self.note_type_id,
+                )
+            )
+
+        return errors
+
+
+class Appointment(AppointmentABC):
+    """
+    Effect to create an appointment.
+
+    Attributes:
+        appointment_note_type_id (UUID | str): The ID of the appointment note type.
+        meeting_link (str | None): The meeting link for the appointment, if any.
+        patient_id (str): The ID of the patient.
+    """
+
+    class Meta:
+        effect_type = "APPOINTMENT"
+
+    appointment_note_type_id: UUID | str
+    meeting_link: str | None = None
+    patient_id: str
+
+    def _get_error_details(self, method: Any) -> list[InitErrorDetails]:
+        """
+        Validates the appointment note type and returns a list of error details if validation fails.
+
+        Args:
+            method (Any): The method being validated.
+
+        Returns:
+            list[InitErrorDetails]: A list of error details for invalid appointment note types or missing patient IDs.
+        """
+        errors = super()._get_error_details(method)
+
+        if not Patient.objects.filter(id=self.patient_id).exists():
+            errors.append(
+                self._create_error_detail(
+                    "value",
+                    "Patient with ID {self.patient_id} does not exist.",
+                    self.patient_id,
+                )
+            )
+
+        category, is_scheduleable = NoteType.objects.values_list("category", "is_scheduleable").get(
+            id=self.appointment_note_type_id
+        )
+        if category != NoteTypeCategories.ENCOUNTER:
+            errors.append(
+                self._create_error_detail(
+                    "value",
+                    f"Appointment note type must be of type, {NoteTypeCategories.ENCOUNTER} but got: {category}.",
+                    self.appointment_note_type_id,
+                )
+            )
+
+        if not is_scheduleable:
+            errors.append(
+                self._create_error_detail(
+                    "value",
+                    "Appointment note type must be scheduleable.",
+                    self.appointment_note_type_id,
+                )
+            )
+
+        return errors
+
+
+__exports__ = ("ScheduleEvent", "Appointment")

canvas_sdk/effects/note/base.py

@@ -0,0 +1,129 @@
+import datetime
+import json
+from abc import ABC
+from dataclasses import dataclass
+from typing import Any
+from uuid import UUID
+
+from pydantic_core import InitErrorDetails
+
+from canvas_generated.messages.effects_pb2 import Effect
+from canvas_sdk.base import TrackableFieldsModel
+from canvas_sdk.v1.data import PracticeLocation, Staff
+from canvas_sdk.v1.data.appointment import AppointmentProgressStatus
+
+
+@dataclass
+class AppointmentIdentifier:
+    """
+    Dataclass for appointment identifiers.
+
+    Attributes:
+        system (str): The system identifier for the appointment.
+        value (str): The value associated with the system identifier.
+    """
+
+    system: str
+    value: str
+
+
+class NoteOrAppointmentABC(TrackableFieldsModel, ABC):
+    """
+    Base class for all note effects.
+
+    Attributes:
+        practice_location_id (UUID | str): The ID of the practice location.
+        provider_id (str): The ID of the provider.
+    """
+
+    class Meta:
+        effect_type = None
+
+    practice_location_id: UUID | str
+    provider_id: str
+
+    def _get_error_details(self, method: Any) -> list[InitErrorDetails]:
+        """
+        Validates the practice location and provider IDs and returns a list of error details if validation fails.
+
+        Args:
+            method (Any): The method being validated.
+
+        Returns:
+            list[InitErrorDetails]: A list of error details for invalid practice location or provider IDs.
+        """
+        errors = super()._get_error_details(method)
+
+        if not PracticeLocation.objects.filter(id=self.practice_location_id).exists():
+            errors.append(
+                self._create_error_detail(
+                    "value",
+                    f"Practice location with ID {self.practice_location_id} does not exist.",
+                    self.practice_location_id,
+                )
+            )
+
+        if not Staff.objects.filter(id=self.provider_id).exists():
+            errors.append(
+                self._create_error_detail(
+                    "value",
+                    "Provider with ID {self.provider_id} does not exist.",
+                    self.provider_id,
+                )
+            )
+
+        return errors
+
+    def create(self) -> Effect:
+        """Originate a new command in the note body."""
+        self._validate_before_effect("create")
+        return Effect(
+            type=f"CREATE_{self.Meta.effect_type}",
+            payload=json.dumps(
+                {
+                    "data": self.values,
+                }
+            ),
+        )
+
+
+class AppointmentABC(NoteOrAppointmentABC, ABC):
+    """
+    Base class for appointment creation effects.
+
+    Attributes:
+        start_time (datetime.datetime): The start time of the appointment.
+        duration_minutes (int): The duration of the appointment in minutes.
+        status (AppointmentProgressStatus | None): The status of the appointment.
+        external_identifiers (list[AppointmentIdentifier] | None): List of external identifiers for the appointment.
+    """
+
+    class Meta:
+        effect_type = "APPOINTMENT"
+
+    _dirty_excluded_keys = [
+        "external_identifiers",
+    ]
+
+    start_time: datetime.datetime
+    duration_minutes: int
+    status: AppointmentProgressStatus | None = None
+    external_identifiers: list[AppointmentIdentifier] | None = None
+
+    @property
+    def values(self) -> dict:
+        """
+        Returns a dictionary of modified attributes with type-specific transformations.
+        """
+        values = super().values
+
+        if self.external_identifiers:
+            values["external_identifiers"] = [
+                {"system": identifier.system, "value": identifier.value}
+                for identifier in self.external_identifiers
+            ]
+
+        return values
+
+
+__exports__ = ("AppointmentIdentifier", "NoteOrAppointmentABC", "AppointmentABC")

canvas_sdk/effects/note/note.py

@@ -0,0 +1,79 @@
+import datetime
+from typing import Any
+from uuid import UUID
+
+from pydantic_core import InitErrorDetails
+
+from canvas_sdk.effects.note.base import NoteOrAppointmentABC
+from canvas_sdk.v1.data import NoteType, Patient
+from canvas_sdk.v1.data.note import NoteTypeCategories
+
+
+class Note(NoteOrAppointmentABC):
+    """
+    Effect to create a visit note.
+
+    Attributes:
+        note_type_id (UUID | str): The ID of the note type.
+        datetime_of_service (datetime.datetime): The date and time of the service.
+        patient_id (str): The ID of the patient.
+    """
+
+    class Meta:
+        effect_type = "NOTE"
+
+    note_type_id: UUID | str
+    datetime_of_service: datetime.datetime
+    patient_id: str
+
+    def _get_error_details(self, method: Any) -> list[InitErrorDetails]:
+        """
+        Validates the note type category and returns a list of error details if validation fails.
+
+        Args:
+            method (Any): The method being validated.
+
+        Returns:
+            list[InitErrorDetails]: A list of error details for invalid note type categories.
+        """
+        errors = super()._get_error_details(method)
+
+        note_type_category = (
+            NoteType.objects.values_list("category", flat=True).filter(id=self.note_type_id).first()
+        )
+
+        if not note_type_category:
+            errors.append(
+                self._create_error_detail(
+                    "value",
+                    f"Note type with ID {self.note_type_id} does not exist.",
+                    self.note_type_id,
+                )
+            )
+        elif note_type_category in (
+            NoteTypeCategories.APPOINTMENT,
+            NoteTypeCategories.SCHEDULE_EVENT,
+            NoteTypeCategories.MESSAGE,
+            NoteTypeCategories.LETTER,
+        ):
+            errors.append(
+                self._create_error_detail(
+                    "value",
+                    f"Visit note type cannot be of type: {note_type_category}.",
+                    self.note_type_id,
+                )
+            )
+
+        if not Patient.objects.filter(id=self.patient_id).exists():
+            errors.append(
+                self._create_error_detail(
+                    "value",
+                    f"Patient with ID {self.patient_id} does not exist.",
+                    self.patient_id,
+                )
+            )
+
+        return errors
+
+
+__exports__ = ("Note",)

canvas_sdk/effects/patient/__init__.py

@@ -0,0 +1,3 @@
+from canvas_sdk.effects.patient.base import Patient, PatientContactPoint
+
+__all__ = __exports__ = ("Patient", "PatientContactPoint")

canvas_sdk/effects/patient/base.py

@@ -0,0 +1,123 @@
+import datetime
+import json
+from dataclasses import dataclass
+from typing import Any
+
+from pydantic_core import InitErrorDetails
+
+from canvas_generated.messages.effects_pb2 import Effect
+from canvas_sdk.base import TrackableFieldsModel
+from canvas_sdk.v1.data import PracticeLocation, Staff
+from canvas_sdk.v1.data.common import ContactPointSystem, ContactPointUse, PersonSex
+
+
+@dataclass
+class PatientContactPoint:
+    """A class representing a patient contact point."""
+
+    system: ContactPointSystem
+    value: str
+    use: ContactPointUse
+    rank: int
+    has_consent: bool | None = None
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert the contact point to a dictionary."""
+        return {
+            "system": self.system.value,
+            "value": self.value,
+            "use": self.use.value,
+            "rank": self.rank,
+            "has_consent": self.has_consent,
+        }
+
+
+class Patient(TrackableFieldsModel):
+    """Effect to create a Patient record."""
+
+    class Meta:
+        effect_type = "PATIENT"
+
+    first_name: str
+    last_name: str
+    middle_name: str | None = None
+    birthdate: datetime.date | None = None
+    prefix: str | None = None
+    suffix: str | None = None
+    sex_at_birth: PersonSex | None = None
+    nickname: str | None = None
+    social_security_number: str | None = None
+    administrative_note: str | None = None
+    clinical_note: str | None = None
+    default_location_id: str | None = None
+    default_provider_id: str | None = None
+    previous_names: list[str] | None = None
+    contact_points: list[PatientContactPoint] | None = None
+
+    @property
+    def values(self) -> dict[str, Any]:
+        """Return the values of the patient as a dictionary."""
+        return {
+            "first_name": self.first_name,
+            "last_name": self.last_name,
+            "middle_name": self.middle_name,
+            "previous_names": self.previous_names or [],
+            "birthdate": self.birthdate.isoformat() if self.birthdate else None,
+            "prefix": self.prefix,
+            "suffix": self.suffix,
+            "sex_at_birth": self.sex_at_birth.value if self.sex_at_birth else None,
+            "nickname": self.nickname,
+            "social_security_number": self.social_security_number,
+            "administrative_note": self.administrative_note,
+            "clinical_note": self.clinical_note,
+            "default_location": self.default_location_id,
+            "default_provider": self.default_provider_id,
+            "contact_points": [cp.to_dict() for cp in self.contact_points]
+            if self.contact_points
+            else None,
+        }
+
+    def _get_error_details(self, method: Any) -> list[InitErrorDetails]:
+        errors = super()._get_error_details(method)
+
+        if (
+            self.default_location_id
+            and not PracticeLocation.objects.filter(id=self.default_location_id).exists()
+        ):
+            errors.append(
+                self._create_error_detail(
+                    "value",
+                    f"Practice location with ID {self.default_location_id} does not exist.",
+                    self.default_location_id,
+                )
+            )
+
+        if (
+            self.default_provider_id
+            and not Staff.objects.filter(id=self.default_provider_id).exists()
+        ):
+            errors.append(
+                self._create_error_detail(
+                    "value",
+                    f"Provider with ID {self.default_provider_id} does not exist.",
+                    self.default_provider_id,
+                )
+            )
+
+        return errors
+
+    def create(self) -> Effect:
+        """Create a new Patient."""
+        self._validate_before_effect("create")
+
+        return Effect(
+            type=f"CREATE_{self.Meta.effect_type}",
+            payload=json.dumps(
+                {
+                    "data": self.values,
+                }
+            ),
+        )
+
+
+__exports__ = ("Patient", "PatientContactPoint")

canvas_sdk/utils/http.py

@@ -1,16 +1,14 @@
 import concurrent
 import functools
 import os
-import time
 import urllib.parse
 from collections.abc import Callable, Iterable, Mapping
 from concurrent.futures import ThreadPoolExecutor
-from functools import wraps
-from typing import Any, Literal, Protocol, TypeVar, cast
+from typing import Any, Literal, Protocol, TypeVar
 
 import requests
 
-from canvas_sdk.utils.stats import StatsDClientProxy
+from canvas_sdk.utils.metrics import measured
 
 F = TypeVar("F", bound=Callable)
 
@@ -117,24 +115,7 @@ class Http:
         self._base_url = base_url
         self._session = requests.Session()
 
-        self.statsd_client = StatsDClientProxy()
-
-    @staticmethod
-    def measure_time(fn: F) -> F:
-        """A decorator to store timing of HTTP calls."""
-
-        @wraps(fn)
-        def wrapper(self: "Http", *args: Any, **kwargs: Any) -> Any:
-            start_time = time.time()
-            result = fn(self, *args, **kwargs)
-            end_time = time.time()
-            timing = int((end_time - start_time) * 1000)
-            self.statsd_client.timing(f"plugins.http_{fn.__name__}", timing, tags={})
-            return result
-
-        return cast(F, wrapper)
-
-    @measure_time
+    @measured(track_plugins_usage=True)
     def get(
         self, url: str, headers: Mapping[str, str | bytes | None] | None = None
     ) -> requests.Response:
@@ -147,7 +128,7 @@ class Http:
             timeout=self._MAX_REQUEST_TIMEOUT_SECONDS,
         )
 
-    @measure_time
+    @measured(track_plugins_usage=True)
     def post(
         self,
         url: str,
@@ -164,7 +145,7 @@ class Http:
             timeout=self._MAX_REQUEST_TIMEOUT_SECONDS,
         )
 
-    @measure_time
+    @measured(track_plugins_usage=True)
     def put(
         self,
         url: str,
@@ -181,7 +162,7 @@ class Http:
             timeout=self._MAX_REQUEST_TIMEOUT_SECONDS,
         )
 
-    @measure_time
+    @measured(track_plugins_usage=True)
     def patch(
         self,
         url: str,
@@ -198,7 +179,7 @@ class Http:
             timeout=self._MAX_REQUEST_TIMEOUT_SECONDS,
         )
 
-    @measure_time
+    @measured(track_plugins_usage=True)
     def batch_requests(
         self,
         batch_requests: Iterable[BatchableRequest],