canvas 0.61.0__py3-none-any.whl → 0.63.0__py3-none-any.whl

canvas_generated/messages/events_pb2.pyi

@@ -863,6 +863,7 @@ class EventType(int, metaclass=_enum_type_wrapper.EnumTypeWrapper):
     PLUGIN_CREATED: _ClassVar[EventType]
     PLUGIN_UPDATED: _ClassVar[EventType]
     APPLICATION__ON_OPEN: _ClassVar[EventType]
+    APPLICATION__ON_CONTEXT_CHANGE: _ClassVar[EventType]
     PATIENT_PORTAL__GET_FORMS: _ClassVar[EventType]
     PATIENT_PORTAL__APPOINTMENT_CANCELED: _ClassVar[EventType]
     PATIENT_PORTAL__APPOINTMENT_RESCHEDULED: _ClassVar[EventType]
@@ -899,6 +900,19 @@ class EventType(int, metaclass=_enum_type_wrapper.EnumTypeWrapper):
     PATIENT_EXTERNAL_IDENTIFIER_DELETED: _ClassVar[EventType]
     PATIENT_METADATA_CREATED: _ClassVar[EventType]
     PATIENT_METADATA_UPDATED: _ClassVar[EventType]
+    APPOINTMENT__FORM__PROVIDERS__PRE_SEARCH: _ClassVar[EventType]
+    APPOINTMENT__FORM__LOCATIONS__PRE_SEARCH: _ClassVar[EventType]
+    APPOINTMENT__FORM__VISIT_TYPES__PRE_SEARCH: _ClassVar[EventType]
+    APPOINTMENT__FORM__DURATIONS__PRE_SEARCH: _ClassVar[EventType]
+    APPOINTMENT__FORM__REASON_FOR_VISIT__PRE_SEARCH: _ClassVar[EventType]
+    APPOINTMENT__FORM__PROVIDERS__POST_SEARCH: _ClassVar[EventType]
+    APPOINTMENT__FORM__LOCATIONS__POST_SEARCH: _ClassVar[EventType]
+    APPOINTMENT__FORM__VISIT_TYPES__POST_SEARCH: _ClassVar[EventType]
+    APPOINTMENT__FORM__DURATIONS__POST_SEARCH: _ClassVar[EventType]
+    APPOINTMENT__FORM__REASON_FOR_VISIT__POST_SEARCH: _ClassVar[EventType]
+    APPOINTMENT__FORM__GET_ADDITIONAL_FIELDS: _ClassVar[EventType]
+    APPOINTMENT_METADATA_CREATED: _ClassVar[EventType]
+    APPOINTMENT_METADATA_UPDATED: _ClassVar[EventType]
     DOCUMENT_REFERENCE_CREATED: _ClassVar[EventType]
     DOCUMENT_REFERENCE_UPDATED: _ClassVar[EventType]
     DOCUMENT_REFERENCE_DELETED: _ClassVar[EventType]
@@ -1763,6 +1777,7 @@ CLAIM__CONDITIONS: EventType
 PLUGIN_CREATED: EventType
 PLUGIN_UPDATED: EventType
 APPLICATION__ON_OPEN: EventType
+APPLICATION__ON_CONTEXT_CHANGE: EventType
 PATIENT_PORTAL__GET_FORMS: EventType
 PATIENT_PORTAL__APPOINTMENT_CANCELED: EventType
 PATIENT_PORTAL__APPOINTMENT_RESCHEDULED: EventType
@@ -1799,6 +1814,19 @@ PATIENT_EXTERNAL_IDENTIFIER_UPDATED: EventType
 PATIENT_EXTERNAL_IDENTIFIER_DELETED: EventType
 PATIENT_METADATA_CREATED: EventType
 PATIENT_METADATA_UPDATED: EventType
+APPOINTMENT__FORM__PROVIDERS__PRE_SEARCH: EventType
+APPOINTMENT__FORM__LOCATIONS__PRE_SEARCH: EventType
+APPOINTMENT__FORM__VISIT_TYPES__PRE_SEARCH: EventType
+APPOINTMENT__FORM__DURATIONS__PRE_SEARCH: EventType
+APPOINTMENT__FORM__REASON_FOR_VISIT__PRE_SEARCH: EventType
+APPOINTMENT__FORM__PROVIDERS__POST_SEARCH: EventType
+APPOINTMENT__FORM__LOCATIONS__POST_SEARCH: EventType
+APPOINTMENT__FORM__VISIT_TYPES__POST_SEARCH: EventType
+APPOINTMENT__FORM__DURATIONS__POST_SEARCH: EventType
+APPOINTMENT__FORM__REASON_FOR_VISIT__POST_SEARCH: EventType
+APPOINTMENT__FORM__GET_ADDITIONAL_FIELDS: EventType
+APPOINTMENT_METADATA_CREATED: EventType
+APPOINTMENT_METADATA_UPDATED: EventType
 DOCUMENT_REFERENCE_CREATED: EventType
 DOCUMENT_REFERENCE_UPDATED: EventType
 DOCUMENT_REFERENCE_DELETED: EventType

canvas_sdk/effects/appointments_metadata/__init__.py

@@ -0,0 +1,13 @@
+from canvas_sdk.effects.appointments_metadata.appointments_metadata_create_form import (
+    AppointmentsMetadataCreateFormEffect,
+    FormField,
+    InputType,
+)
+from canvas_sdk.effects.appointments_metadata.base import AppointmentsMetadata
+
+__all__ = __exports__ = (
+    "FormField",
+    "InputType",
+    "AppointmentsMetadata",
+    "AppointmentsMetadataCreateFormEffect",
+)

canvas_sdk/effects/appointments_metadata/appointments_metadata_create_form.py

@@ -0,0 +1,12 @@
+from canvas_sdk.effects import EffectType
+from canvas_sdk.effects.form import BaseCreateFormEffect, FormField, InputType  # noqa
+
+
+class AppointmentsMetadataCreateFormEffect(BaseCreateFormEffect):
+    """An Effect that will create a form."""
+
+    class Meta:
+        effect_type = EffectType.APPOINTMENT__FORM__CREATE_ADDITIONAL_FIELDS
+
+
+__exports__ = ("AppointmentsMetadataCreateFormEffect", "FormField", "InputType")

canvas_sdk/effects/appointments_metadata/base.py

@@ -0,0 +1,30 @@
+from typing import Any
+
+from canvas_sdk.effects.metadata import BaseMetadata
+from canvas_sdk.v1.data import Appointment
+
+
+class AppointmentsMetadata(BaseMetadata):
+    """Effect to upsert an Appointment Metadata record."""
+
+    class Meta:
+        effect_type = "APPOINTMENT_METADATA"
+
+    appointment_id: str
+
+    def _get_error_details(self, method: Any) -> list:
+        errors = super()._get_error_details(method)
+
+        if not Appointment.objects.filter(id=self.appointment_id).exists():
+            errors.append(
+                self._create_error_detail(
+                    "appointment_id",
+                    f"Appointment with id: {self.appointment_id} does not exist.",
+                    self.appointment_id,
+                )
+            )
+
+        return errors
+
+
+__exports__ = ("AppointmentsMetadata",)

canvas_sdk/effects/calendar/__init__.py

@@ -0,0 +1,4 @@
+from canvas_sdk.effects.calendar.create_calendar import CalendarType, CreateCalendar
+from canvas_sdk.effects.calendar.create_event import CreateEvent, EventRecurrence
+
+__all__ = __exports__ = ("CreateCalendar", "CalendarType", "CreateEvent", "EventRecurrence")

canvas_sdk/effects/calendar/create_calendar.py

@@ -0,0 +1,40 @@
+from enum import StrEnum
+from typing import Any
+from uuid import UUID
+
+from canvas_sdk.effects import EffectType, _BaseEffect
+
+
+class CalendarType(StrEnum):
+    """Calendar type."""
+
+    Clinic = "Clinic"
+    Administrative = "Admin"
+
+
+class CreateCalendar(_BaseEffect):
+    """Effect to create a Calendar."""
+
+    class Meta:
+        effect_type = EffectType.CALENDAR__CREATE
+
+    id: str | UUID | None = None
+    provider: str | UUID
+    type: CalendarType
+    description: str | None = None
+
+    @property
+    def values(self) -> dict[str, Any]:
+        """The Calendar's values."""
+        return {
+            "id": self.id,
+            "provider": self.provider,
+            "type": self.type,
+            "description": self.description,
+        }
+
+
+__exports__ = (
+    "CreateCalendar",
+    "CalendarType",
+)

canvas_sdk/effects/calendar/create_event.py

@@ -0,0 +1,43 @@
+from datetime import datetime
+from enum import StrEnum
+from typing import Any
+from uuid import UUID
+
+from canvas_sdk.effects import EffectType, _BaseEffect
+
+
+class EventRecurrence(StrEnum):
+    """Calendar event recurrence."""
+
+    Daily = "FREQ=DAILY"
+    Weekly = "FREQ=WEEKLY"
+
+
+class CreateEvent(_BaseEffect):
+    """Effect to create a Calendar event."""
+
+    class Meta:
+        effect_type = EffectType.CALENDAR__EVENT__CREATE
+
+    calendar_id: str | UUID
+    title: str
+    starts_at: datetime
+    ends_at: datetime
+    recurrence: EventRecurrence
+
+    @property
+    def values(self) -> dict[str, Any]:
+        """The event's values."""
+        return {
+            "calendar_id": self.calendar_id,
+            "title": self.title,
+            "starts_at": self.starts_at.isoformat(),
+            "ends_at": self.ends_at.isoformat(),
+            "recurrence": self.recurrence,
+        }
+
+
+__exports__ = (
+    "CreateEvent",
+    "EventRecurrence",
+)

canvas_sdk/effects/form.py

@@ -0,0 +1,69 @@
+from dataclasses import dataclass
+from enum import StrEnum
+from typing import Any
+
+from pydantic_core import InitErrorDetails
+
+from canvas_sdk.effects import _BaseEffect
+
+
+class InputType(StrEnum):
+    """Type of input for a form field."""
+
+    TEXT = "text"
+    SELECT = "select"
+    DATE = "date"
+
+
+@dataclass
+class FormField:
+    """A class representing a Field."""
+
+    key: str | None = None
+    label: str | None = None
+    required: bool = False
+    editable: bool = True
+    type: InputType = InputType.TEXT
+    options: list[str] | None = None
+    value: str | None = None
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert the Field to a dictionary."""
+        return {
+            "key": self.key,
+            "label": self.label,
+            "required": self.required,
+            "editable": self.editable,
+            "type": self.type.value,
+            "options": self.options,
+            "value": self.value,
+        }
+
+
+class BaseCreateFormEffect(_BaseEffect):
+    """Base class for form creation effects."""
+
+    form_fields: list[FormField]
+
+    @property
+    def values(self) -> dict[str, Any]:
+        """Return the values of the form as a dictionary."""
+        return {"form": [field.to_dict() for field in self.form_fields]}
+
+    def _get_error_details(self, method: Any) -> list[InitErrorDetails]:
+        errors = super()._get_error_details(method)
+
+        for field in self.form_fields:
+            if field.type != InputType.SELECT and field.options:
+                errors.append(
+                    self._create_error_detail(
+                        "value",
+                        "The options attribute is only used for fields of type select",
+                        field.key,
+                    )
+                )
+
+        return errors
+
+
+__exports__ = ()

canvas_sdk/effects/generate_full_chart_pdf.py

@@ -0,0 +1,56 @@
+from typing import Any
+
+from pydantic import Field
+from pydantic_core import InitErrorDetails
+
+from canvas_generated.messages.effects_pb2 import EffectType
+from canvas_sdk.effects.base import _BaseEffect
+from canvas_sdk.v1.data import Patient, Staff
+
+
+class GenerateFullChartPDFEffect(_BaseEffect):
+    """
+    An Effect that will generate a full chart PDF for a patient.
+
+    Generated PDF will appear in task list assigned to requestor with "chart pdf" label within 10 minutes.
+    """
+
+    class Meta:
+        effect_type = EffectType.GENERATE_FULL_CHART_PDF
+
+    patient_id: str = Field(min_length=1)
+    requestor_staff_id: str = Field(min_length=1)
+
+    @property
+    def values(self) -> dict[str, Any]:
+        """The GenerateFullChartPDFEffect's values."""
+        return {
+            "patient_id": self.patient_id,
+            "requestor_staff_id": self.requestor_staff_id,
+        }
+
+    def _get_error_details(self, method: Any) -> list[InitErrorDetails]:
+        errors = super()._get_error_details(method)
+
+        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,
+                )
+            )
+
+        if not Staff.objects.filter(id=self.requestor_staff_id).exists():
+            errors.append(
+                self._create_error_detail(
+                    "value",
+                    f"Requestor staff with ID {self.requestor_staff_id} does not exist.",
+                    self.requestor_staff_id,
+                )
+            )
+
+        return errors
+
+
+__exports__ = ("GenerateFullChartPDFEffect",)

canvas_sdk/effects/metadata.py

@@ -0,0 +1,26 @@
+import json
+
+from canvas_generated.messages.effects_pb2 import Effect
+from canvas_sdk.base import TrackableFieldsModel
+
+
+class BaseMetadata(TrackableFieldsModel):
+    """Base class for metadata effects."""
+
+    key: str
+
+    def upsert(self, value: str) -> Effect:
+        """Upsert the metadata."""
+        self._validate_before_effect("upsert")
+
+        return Effect(
+            type=f"UPSERT_{self.Meta.effect_type}",  # type: ignore[attr-defined]
+            payload=json.dumps(
+                {
+                    "data": {**self.values, "value": value},
+                }
+            ),
+        )
+
+
+__exports__ = ()

canvas_sdk/effects/note/base.py

@@ -57,14 +57,6 @@ class NoteOrAppointmentABC(TrackableFieldsModel, ABC):
         errors = super()._get_error_details(method)
 
         if method == "create":
-            if self.instance_id:
-                errors.append(
-                    self._create_error_detail(
-                        "value",
-                        "Instance ID should not be provided for create effects.",
-                        self.instance_id,
-                    )
-                )
             if not self.practice_location_id:
                 errors.append(
                     self._create_error_detail(
@@ -167,11 +159,35 @@ class AppointmentABC(NoteOrAppointmentABC, ABC):
     duration_minutes: int | None = None
     status: AppointmentProgressStatus | None = None
     external_identifiers: list[AppointmentIdentifier] | None = None
+    parent_appointment_id: str | UUID | None = None
 
     def _get_error_details(self, method: Any) -> list[InitErrorDetails]:
         """Validates the appointment instance and returns a list of error details if validation fails."""
         errors = super()._get_error_details(method)
 
+        if method != "create" and self.parent_appointment_id:
+            errors.append(
+                self._create_error_detail(
+                    "value",
+                    "parent_appointment_id can only be set when creating an appointment.",
+                    self.parent_appointment_id,
+                )
+            )
+
+        # parent_appointment_id needs to be a different appointment
+        if (
+            self.parent_appointment_id
+            and self.instance_id
+            and self.parent_appointment_id == self.instance_id
+        ):
+            errors.append(
+                self._create_error_detail(
+                    "value",
+                    "parent_appointment_id cannot be the same as instance_id",
+                    self.parent_appointment_id,
+                )
+            )
+
         if method == "create":
             # Additional required fields for appointment creation
             if not self.start_time:

canvas_sdk/effects/note/note.py

@@ -67,6 +67,16 @@ class Note(NoteOrAppointmentABC):
                         None,
                     )
                 )
+
+            if self.instance_id and NoteModel.objects.filter(id=self.instance_id).exists():
+                errors.append(
+                    self._create_error_detail(
+                        "value",
+                        f"Note with ID {self.instance_id} already exists.",
+                        self.instance_id,
+                    )
+                )
+
         elif method == "update":
             if self.note_type_id:
                 errors.append(
@@ -85,14 +95,14 @@ class Note(NoteOrAppointmentABC):
                     )
                 )
 
-        if self.instance_id and not NoteModel.objects.filter(id=self.instance_id).exists():
-            errors.append(
-                self._create_error_detail(
-                    "value",
-                    f"Note with ID {self.instance_id} does not exist.",
-                    self.instance_id,
+            if self.instance_id and not NoteModel.objects.filter(id=self.instance_id).exists():
+                errors.append(
+                    self._create_error_detail(
+                        "value",
+                        f"Note with ID {self.instance_id} does not exist.",
+                        self.instance_id,
+                    )
                 )
-            )
 
         if self.note_type_id:
             note_type_category = (

canvas_sdk/effects/patient_metadata/base.py

@@ -1,21 +1,18 @@
-import json
 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.effects.metadata import BaseMetadata
 from canvas_sdk.v1.data import Patient
 
 
-class PatientMetadata(TrackableFieldsModel):
+class PatientMetadata(BaseMetadata):
     """Effect to upsert a Patient Metadata record."""
 
     class Meta:
         effect_type = "PATIENT_METADATA"
 
     patient_id: str
-    key: str
 
     def _get_error_details(self, method: Any) -> list[InitErrorDetails]:
         errors = super()._get_error_details(method)
@@ -31,18 +28,5 @@ class PatientMetadata(TrackableFieldsModel):
 
         return errors
 
-    def upsert(self, value: str) -> Effect:
-        """Upsert the patient metadata."""
-        self._validate_before_effect("upsert")
-
-        return Effect(
-            type=f"UPSERT_{self.Meta.effect_type}",
-            payload=json.dumps(
-                {
-                    "data": {**self.values, "value": value},
-                }
-            ),
-        )
-
 
 __exports__ = ("PatientMetadata",)

canvas_sdk/effects/patient_metadata/patient_metadata_create_form.py

@@ -1,70 +1,12 @@
-from dataclasses import dataclass
-from enum import StrEnum
-from typing import Any
+from canvas_sdk.effects import EffectType
+from canvas_sdk.effects.form import BaseCreateFormEffect, FormField, InputType  # noqa
 
-from pydantic_core import InitErrorDetails
 
-from canvas_sdk.effects import EffectType, _BaseEffect
-
-
-class InputType(StrEnum):
-    """Type of input for a form field."""
-
-    TEXT = "text"
-    SELECT = "select"
-    DATE = "date"
-
-
-@dataclass
-class FormField:
-    """A class representing a Field."""
-
-    key: str | None = None
-    label: str | None = None
-    required: bool = False
-    editable: bool = True
-    type: InputType = InputType.TEXT
-    options: list[str] | None = None
-
-    def to_dict(self) -> dict[str, Any]:
-        """Convert the Field to a dictionary."""
-        return {
-            "key": self.key,
-            "label": self.label,
-            "required": self.required,
-            "editable": self.editable,
-            "type": self.type.value,
-            "options": self.options,
-        }
-
-
-class PatientMetadataCreateFormEffect(_BaseEffect):
+class PatientMetadataCreateFormEffect(BaseCreateFormEffect):
     """An Effect that will create a form."""
 
     class Meta:
         effect_type = EffectType.PATIENT_METADATA__CREATE_ADDITIONAL_FIELDS
 
-    form_fields: list[FormField]
-
-    @property
-    def values(self) -> dict[str, Any]:
-        """Return the values of the form as a dictionary."""
-        return {"form": [field.to_dict() for field in self.form_fields]}
-
-    def _get_error_details(self, method: Any) -> list[InitErrorDetails]:
-        errors = super()._get_error_details(method)
-
-        for field in self.form_fields:
-            if field.type != InputType.SELECT and field.options:
-                errors.append(
-                    self._create_error_detail(
-                        "value",
-                        "The options attribute is only used for fields of type select",
-                        field.key,
-                    )
-                )
-
-        return errors
-
 
 __exports__ = ("PatientMetadataCreateFormEffect", "FormField", "InputType")

canvas_sdk/handlers/application.py

@@ -8,13 +8,21 @@ from canvas_sdk.handlers import BaseHandler
 class Application(BaseHandler, ABC):
     """An embeddable application that can be registered to Canvas."""
 
-    RESPONDS_TO = [EventType.Name(EventType.APPLICATION__ON_OPEN)]
+    RESPONDS_TO = [
+        EventType.Name(EventType.APPLICATION__ON_OPEN),
+        EventType.Name(EventType.APPLICATION__ON_CONTEXT_CHANGE),
+    ]
 
     def compute(self) -> list[Effect]:
         """Handle the application events."""
         match self.event.type:
             case EventType.APPLICATION__ON_OPEN:
                 return [self.on_open()] if self.event.target.id == self.identifier else []
+            case EventType.APPLICATION__ON_CONTEXT_CHANGE:
+                if self.event.target.id == self.identifier:
+                    effect = self.on_context_change()
+                    return [effect] if effect is not None else []
+                return []
             case _:
                 return []
 
@@ -23,6 +31,10 @@ class Application(BaseHandler, ABC):
         """Handle the application open event."""
         ...
 
+    def on_context_change(self) -> Effect | None:
+        """Handle the application context change event."""
+        return None
+
     @property
     def identifier(self) -> str:
         """The application identifier."""

canvas_sdk/v1/data/__init__.py

@@ -1,5 +1,5 @@
 from .allergy_intolerance import AllergyIntolerance, AllergyIntoleranceCoding
-from .appointment import Appointment, AppointmentExternalIdentifier
+from .appointment import Appointment, AppointmentExternalIdentifier, AppointmentMetadata
 from .assessment import Assessment
 from .banner_alert import BannerAlert
 from .billing import BillingLineItem, BillingLineItemModifier
@@ -18,6 +18,12 @@ from .discount import Discount
 from .facility import Facility
 from .goal import Goal
 from .imaging import ImagingOrder, ImagingReport, ImagingReview
+from .immunization import (
+    Immunization,
+    ImmunizationCoding,
+    ImmunizationStatement,
+    ImmunizationStatementCoding,
+)
 from .invoice import Invoice
 from .lab import (
     LabOrder,
@@ -93,6 +99,7 @@ from .user import CanvasUser
 
 __all__ = __exports__ = (
     "Appointment",
+    "AppointmentMetadata",
     "AppointmentExternalIdentifier",
     "AllergyIntolerance",
     "AllergyIntoleranceCoding",
@@ -129,6 +136,10 @@ __all__ = __exports__ = (
     "ImagingOrder",
     "ImagingReport",
     "ImagingReview",
+    "Immunization",
+    "ImmunizationCoding",
+    "ImmunizationStatement",
+    "ImmunizationStatementCoding",
     "InstallmentPlan",
     "Interview",
     "InterviewQuestionnaireMap",

canvas_sdk/v1/data/appointment.py

@@ -29,6 +29,11 @@ class Appointment(IdentifiableModel):
         related_name="appointments",
         null=True,
     )
+
+    parent_appointment = models.ForeignKey(
+        "self", on_delete=models.CASCADE, null=True, blank=True, related_name="children"
+    )
+
     appointment_rescheduled_from = models.ForeignKey(
         "self",
         on_delete=models.DO_NOTHING,
@@ -74,8 +79,22 @@ class AppointmentExternalIdentifier(IdentifiableModel):
     )
 
 
+class AppointmentMetadata(IdentifiableModel):
+    """A class representing Appointment Metadata."""
+
+    class Meta:
+        db_table = "canvas_sdk_data_api_appointmentmetadata_001"
+
+    appointment = models.ForeignKey(
+        "v1.Appointment", on_delete=models.CASCADE, related_name="metadata", null=True
+    )
+    key = models.CharField(max_length=32)
+    value = models.CharField(max_length=256)
+
+
 __exports__ = (
     "AppointmentProgressStatus",
     "Appointment",
+    "AppointmentMetadata",
     "AppointmentExternalIdentifier",
 )