canvas 0.72.1__py3-none-any.whl → 0.74.0__py3-none-any.whl

canvas_generated/messages/events_pb2.pyi

@@ -93,12 +93,16 @@ class EventType(int, metaclass=_enum_type_wrapper.EnumTypeWrapper):
     DETECTED_ISSUE_UPDATED: _ClassVar[EventType]
     TASK_CLOSED: _ClassVar[EventType]
     TASK_COMPLETED: _ClassVar[EventType]
+    TASK_METADATA_CREATED: _ClassVar[EventType]
+    TASK_METADATA_UPDATED: _ClassVar[EventType]
     DETECTED_ISSUE_EVIDENCE_CREATED: _ClassVar[EventType]
     DETECTED_ISSUE_EVIDENCE_UPDATED: _ClassVar[EventType]
     STAFF_ACTIVATED: _ClassVar[EventType]
     STAFF_DEACTIVATED: _ClassVar[EventType]
     COMPOUND_MEDICATION_CREATED: _ClassVar[EventType]
     COMPOUND_MEDICATION_UPDATED: _ClassVar[EventType]
+    APPOINTMENT_LABEL_ADDED: _ClassVar[EventType]
+    APPOINTMENT_LABEL_REMOVED: _ClassVar[EventType]
     PRE_COMMAND_ORIGINATE: _ClassVar[EventType]
     POST_COMMAND_ORIGINATE: _ClassVar[EventType]
     PRE_COMMAND_UPDATE: _ClassVar[EventType]
@@ -142,6 +146,8 @@ class EventType(int, metaclass=_enum_type_wrapper.EnumTypeWrapper):
     ADJUST_PRESCRIPTION__CHANGE_MEDICATION_TO__POST_SEARCH: _ClassVar[EventType]
     ADJUST_PRESCRIPTION__SUPERVISING_PROVIDER__PRE_SEARCH: _ClassVar[EventType]
     ADJUST_PRESCRIPTION__SUPERVISING_PROVIDER__POST_SEARCH: _ClassVar[EventType]
+    ADJUST_PRESCRIPTION__PRESCRIBER__PRE_SEARCH: _ClassVar[EventType]
+    ADJUST_PRESCRIPTION__PRESCRIBER__POST_SEARCH: _ClassVar[EventType]
     ALLERGY_COMMAND__PRE_ORIGINATE: _ClassVar[EventType]
     ALLERGY_COMMAND__POST_ORIGINATE: _ClassVar[EventType]
     ALLERGY_COMMAND__PRE_UPDATE: _ClassVar[EventType]
@@ -523,6 +529,8 @@ class EventType(int, metaclass=_enum_type_wrapper.EnumTypeWrapper):
     PRESCRIBE__PHARMACY__POST_SEARCH: _ClassVar[EventType]
     PRESCRIBE__SUPERVISING_PROVIDER__POST_SEARCH: _ClassVar[EventType]
     PRESCRIBE__SUPERVISING_PROVIDER__PRE_SEARCH: _ClassVar[EventType]
+    PRESCRIBE__PRESCRIBER__PRE_SEARCH: _ClassVar[EventType]
+    PRESCRIBE__PRESCRIBER__POST_SEARCH: _ClassVar[EventType]
     QUESTIONNAIRE_COMMAND__PRE_ORIGINATE: _ClassVar[EventType]
     QUESTIONNAIRE_COMMAND__POST_ORIGINATE: _ClassVar[EventType]
     QUESTIONNAIRE_COMMAND__PRE_UPDATE: _ClassVar[EventType]
@@ -599,6 +607,8 @@ class EventType(int, metaclass=_enum_type_wrapper.EnumTypeWrapper):
     REFILL__PHARMACY__POST_SEARCH: _ClassVar[EventType]
     REFILL__SUPERVISING_PROVIDER__PRE_SEARCH: _ClassVar[EventType]
     REFILL__SUPERVISING_PROVIDER__POST_SEARCH: _ClassVar[EventType]
+    REFILL__PRESCRIBER__PRE_SEARCH: _ClassVar[EventType]
+    REFILL__PRESCRIBER__POST_SEARCH: _ClassVar[EventType]
     REMOVE_ALLERGY_COMMAND__PRE_ORIGINATE: _ClassVar[EventType]
     REMOVE_ALLERGY_COMMAND__POST_ORIGINATE: _ClassVar[EventType]
     REMOVE_ALLERGY_COMMAND__PRE_UPDATE: _ClassVar[EventType]
@@ -1011,12 +1021,16 @@ DETECTED_ISSUE_CREATED: EventType
 DETECTED_ISSUE_UPDATED: EventType
 TASK_CLOSED: EventType
 TASK_COMPLETED: EventType
+TASK_METADATA_CREATED: EventType
+TASK_METADATA_UPDATED: EventType
 DETECTED_ISSUE_EVIDENCE_CREATED: EventType
 DETECTED_ISSUE_EVIDENCE_UPDATED: EventType
 STAFF_ACTIVATED: EventType
 STAFF_DEACTIVATED: EventType
 COMPOUND_MEDICATION_CREATED: EventType
 COMPOUND_MEDICATION_UPDATED: EventType
+APPOINTMENT_LABEL_ADDED: EventType
+APPOINTMENT_LABEL_REMOVED: EventType
 PRE_COMMAND_ORIGINATE: EventType
 POST_COMMAND_ORIGINATE: EventType
 PRE_COMMAND_UPDATE: EventType
@@ -1060,6 +1074,8 @@ ADJUST_PRESCRIPTION__CHANGE_MEDICATION_TO__PRE_SEARCH: EventType
 ADJUST_PRESCRIPTION__CHANGE_MEDICATION_TO__POST_SEARCH: EventType
 ADJUST_PRESCRIPTION__SUPERVISING_PROVIDER__PRE_SEARCH: EventType
 ADJUST_PRESCRIPTION__SUPERVISING_PROVIDER__POST_SEARCH: EventType
+ADJUST_PRESCRIPTION__PRESCRIBER__PRE_SEARCH: EventType
+ADJUST_PRESCRIPTION__PRESCRIBER__POST_SEARCH: EventType
 ALLERGY_COMMAND__PRE_ORIGINATE: EventType
 ALLERGY_COMMAND__POST_ORIGINATE: EventType
 ALLERGY_COMMAND__PRE_UPDATE: EventType
@@ -1441,6 +1457,8 @@ PRESCRIBE__PHARMACY__PRE_SEARCH: EventType
 PRESCRIBE__PHARMACY__POST_SEARCH: EventType
 PRESCRIBE__SUPERVISING_PROVIDER__POST_SEARCH: EventType
 PRESCRIBE__SUPERVISING_PROVIDER__PRE_SEARCH: EventType
+PRESCRIBE__PRESCRIBER__PRE_SEARCH: EventType
+PRESCRIBE__PRESCRIBER__POST_SEARCH: EventType
 QUESTIONNAIRE_COMMAND__PRE_ORIGINATE: EventType
 QUESTIONNAIRE_COMMAND__POST_ORIGINATE: EventType
 QUESTIONNAIRE_COMMAND__PRE_UPDATE: EventType
@@ -1517,6 +1535,8 @@ REFILL__PHARMACY__PRE_SEARCH: EventType
 REFILL__PHARMACY__POST_SEARCH: EventType
 REFILL__SUPERVISING_PROVIDER__PRE_SEARCH: EventType
 REFILL__SUPERVISING_PROVIDER__POST_SEARCH: EventType
+REFILL__PRESCRIBER__PRE_SEARCH: EventType
+REFILL__PRESCRIBER__POST_SEARCH: EventType
 REMOVE_ALLERGY_COMMAND__PRE_ORIGINATE: EventType
 REMOVE_ALLERGY_COMMAND__POST_ORIGINATE: EventType
 REMOVE_ALLERGY_COMMAND__PRE_UPDATE: EventType

canvas_sdk/effects/claim_label.py

@@ -0,0 +1,93 @@
+from dataclasses import dataclass
+from typing import Any
+from uuid import UUID
+
+from pydantic import conlist
+from pydantic_core import InitErrorDetails
+
+from canvas_sdk.effects.base import EffectType, _BaseEffect
+from canvas_sdk.v1.data import Claim
+from canvas_sdk.v1.data.common import ColorEnum
+
+
+@dataclass
+class Label:
+    """A class representing a label."""
+
+    color: ColorEnum
+    name: str
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert the label to a dictionary."""
+        return {"color": self.color.value, "name": self.name}
+
+
+class _ClaimLabelBase(_BaseEffect):
+    """Base class for managing ClaimLabels."""
+
+    claim_id: UUID | str
+    labels: conlist(str | Label, min_length=1)  # type: ignore
+
+    def _check_if_claim_exists(self) -> list[InitErrorDetails]:
+        if Claim.objects.filter(id=self.claim_id).exists():
+            return []
+        return [
+            (
+                self._create_error_detail(
+                    "value",
+                    f"Claim with id {self.claim_id} does not exist.",
+                    self.claim_id,
+                )
+            )
+        ]
+
+    def _get_error_details(self, method: Any) -> list[InitErrorDetails]:
+        errors = super()._get_error_details(method)
+        if not Claim.objects.filter(id=self.claim_id).exists():
+            errors.append(
+                self._create_error_detail(
+                    "value",
+                    f"Claim with id {self.claim_id} does not exist.",
+                    self.claim_id,
+                )
+            )
+        return errors
+
+
+class AddClaimLabel(_ClaimLabelBase):
+    """Effect to add a label to a Claim."""
+
+    class Meta:
+        effect_type = EffectType.ADD_CLAIM_LABEL
+
+    @property
+    def values(self) -> dict[str, Any]:
+        """The values for adding a claim label."""
+        return {
+            "claim_id": str(self.claim_id),
+            "labels": [
+                label.to_dict() if isinstance(label, Label) else {"name": label}
+                for label in self.labels
+            ],
+        }
+
+
+class RemoveClaimLabel(_ClaimLabelBase):
+    """Effect to remove a label from a Claim."""
+
+    class Meta:
+        effect_type = EffectType.REMOVE_CLAIM_LABEL
+
+    labels: conlist(str, min_length=1)  # type: ignore
+
+    @property
+    def values(self) -> dict[str, Any]:
+        """The values for removing a claim label."""
+        return {"claim_id": str(self.claim_id), "labels": list(self.labels)}
+
+
+__exports__ = (
+    "Label",
+    "AddClaimLabel",
+    "RemoveClaimLabel",
+)

canvas_sdk/effects/claim_line_item.py

@@ -0,0 +1,47 @@
+from typing import Any
+from uuid import UUID
+
+from pydantic_core import InitErrorDetails
+
+from canvas_sdk.effects.base import EffectType, _BaseEffect
+from canvas_sdk.v1.data import ClaimLineItem
+
+
+class UpdateClaimLineItem(_BaseEffect):
+    """
+    An Effect that updates a Claim Line Item.
+    """
+
+    class Meta:
+        effect_type = EffectType.UPDATE_CLAIM_LINE_ITEM
+
+    claim_line_item_id: str | UUID
+    charge: float | None = None
+
+    @property
+    def values(self) -> dict[str, Any]:
+        """The values for the payload."""
+        if self.charge is None:
+            return {}
+        return {"charge": str(self.charge)}
+
+    @property
+    def effect_payload(self) -> dict[str, Any]:
+        """The payload of the effect."""
+        return {"data": self.values, "claim_line_item_id": str(self.claim_line_item_id)}
+
+    def _get_error_details(self, method: Any) -> list[InitErrorDetails]:
+        errors = super()._get_error_details(method)
+
+        if not ClaimLineItem.objects.filter(id=self.claim_line_item_id).exists():
+            errors.append(
+                self._create_error_detail(
+                    "value",
+                    "Claim Line Item does not exist",
+                    self.claim_line_item_id,
+                )
+            )
+        return errors
+
+
+__exports__ = ("UpdateClaimLineItem",)

canvas_sdk/effects/fax/__init__.py

@@ -0,0 +1,3 @@
+from canvas_sdk.effects.fax.note import FaxNoteEffect
+
+__all__ = __exports__ = ("FaxNoteEffect",)

canvas_sdk/effects/fax/base.py

@@ -0,0 +1,77 @@
+from abc import ABC
+from typing import Any, Literal
+from uuid import UUID
+
+from pydantic_core import InitErrorDetails
+
+from canvas_sdk.effects import EffectType, _BaseEffect
+from canvas_sdk.v1.data import PracticeLocation
+
+
+class BaseFaxEffect(_BaseEffect, ABC):
+    """Base class for fax effects."""
+
+    class Meta:
+        effect_type = EffectType.UNKNOWN_EFFECT
+
+    recipient_name: str
+    recipient_fax_number: str
+    include_coversheet: bool = False
+    subject: str | None = None
+    comment: str | None = None
+    location_id: str | UUID | None = None
+
+    def _get_error_details(self, method: Literal["apply"]) -> list[InitErrorDetails]:
+        errors = super()._get_error_details(method)
+
+        if self.include_coversheet:
+            if not self.subject:
+                errors.append(
+                    self._create_error_detail(
+                        "value",
+                        "subject is required when include_coversheet is True",
+                        self.subject,
+                    )
+                )
+            if not self.comment:
+                errors.append(
+                    self._create_error_detail(
+                        "value",
+                        "comment is required when include_coversheet is True",
+                        self.comment,
+                    )
+                )
+            if self.location_id:
+                if not PracticeLocation.objects.filter(id=self.location_id).exists():
+                    errors.append(
+                        self._create_error_detail(
+                            "value",
+                            f"Practice Location {self.location_id} does not exist",
+                            self.location_id,
+                        )
+                    )
+            else:
+                errors.append(
+                    self._create_error_detail(
+                        "value",
+                        "location_id is required when include_coversheet is True",
+                        self.location_id,
+                    )
+                )
+
+        return errors
+
+    @property
+    def values(self) -> dict[str, Any]:
+        """Return the values of the fax effect."""
+        return {
+            "recipient_name": self.recipient_name,
+            "recipient_fax_number": self.recipient_fax_number,
+            "include_coversheet": self.include_coversheet,
+            "subject": self.subject,
+            "comment": self.comment,
+            "location_id": str(self.location_id) if self.location_id else None,
+        }
+
+
+__exports__ = ()

canvas_sdk/effects/fax/note.py

@@ -0,0 +1,42 @@
+from typing import Literal
+from uuid import UUID
+
+from pydantic_core import InitErrorDetails
+
+from canvas_generated.messages.effects_pb2 import EffectType
+from canvas_sdk.effects.fax.base import BaseFaxEffect
+from canvas_sdk.v1.data import Note
+
+
+class FaxNoteEffect(BaseFaxEffect):
+    """Fax note effect."""
+
+    class Meta:
+        effect_type = EffectType.FAX_NOTE
+
+    note_id: str | UUID
+
+    def _get_error_details(self, method: Literal["apply"]) -> list[InitErrorDetails]:
+        errors = super()._get_error_details(method)
+        if self.note_id and not Note.objects.filter(id=self.note_id).exists():
+            errors.append(
+                self._create_error_detail(
+                    "value",
+                    f"Note with ID {self.note_id} does not exist.",
+                    self.note_id,
+                )
+            )
+
+        return errors
+
+    @property
+    def values(self) -> dict[str, str]:
+        """Return the values of the note fax effect."""
+        values = super().values
+        return {
+            **values,
+            "note_id": str(self.note_id),
+        }
+
+
+__exports__ = ()

canvas_sdk/effects/note/__init__.py

@@ -1,4 +1,9 @@
-from canvas_sdk.effects.note.appointment import Appointment, ScheduleEvent
+from canvas_sdk.effects.note.appointment import (
+    AddAppointmentLabel,
+    Appointment,
+    RemoveAppointmentLabel,
+    ScheduleEvent,
+)
 from canvas_sdk.effects.note.base import AppointmentIdentifier
 from canvas_sdk.effects.note.note import Note
 
@@ -7,4 +12,6 @@ __all__ = __exports__ = (
     "Note",
     "Appointment",
     "ScheduleEvent",
+    "AddAppointmentLabel",
+    "RemoveAppointmentLabel",
 )

canvas_sdk/effects/note/appointment.py

@@ -1,12 +1,17 @@
 import json
-from typing import Any
+from typing import Annotated, Any
 from uuid import UUID
 
+from django.db.models import Count
+from pydantic import Field
 from pydantic_core import InitErrorDetails
 
-from canvas_sdk.effects import Effect
+from canvas_sdk.base import TrackableFieldsModel
+from canvas_sdk.effects import Effect, EffectType
+from canvas_sdk.effects.base import _BaseEffect
 from canvas_sdk.effects.note.base import AppointmentABC
-from canvas_sdk.v1.data import NoteType, Patient
+from canvas_sdk.v1.data import Appointment as AppointmentDataModel
+from canvas_sdk.v1.data import AppointmentLabel, NoteType, Patient
 from canvas_sdk.v1.data.note import NoteTypeCategories
 
 
@@ -127,6 +132,7 @@ class Appointment(AppointmentABC):
         appointment_note_type_id (UUID | str | None): The ID of the appointment note type.
         meeting_link (str | None): The meeting link for the appointment, if any.
         patient_id (str | None): The ID of the patient.
+        labels (conset[str] | None): A set of label names to apply to the appointment.
     """
 
     class Meta:
@@ -135,6 +141,13 @@ class Appointment(AppointmentABC):
     appointment_note_type_id: UUID | str | None = None
     meeting_link: str | None = None
     patient_id: str | None = None
+    labels: (
+        Annotated[
+            set[Annotated[str, Field(min_length=1, max_length=50)]],
+            Field(min_length=1, max_length=3),
+        ]
+        | None
+    ) = None
 
     def _get_error_details(self, method: Any) -> list[InitErrorDetails]:
         """
@@ -215,8 +228,39 @@ class Appointment(AppointmentABC):
                     )
                 )
 
+        if method == "update" and self.labels and self.instance_id:
+            existing_count = AppointmentLabel.objects.filter(
+                appointment__id=self.instance_id
+            ).count()
+            if existing_count + len(self.labels) > 3:
+                errors.append(
+                    self._create_error_detail(
+                        "value",
+                        f"Limit reached: Only 3 appointment labels allowed. Attempted to add {len(self.labels)} label(s) to appointment with {existing_count} existing label(s).",
+                        sorted(self.labels),
+                    )
+                )
+
         return errors
 
+    @property
+    def values(self) -> dict:
+        """
+        Returns a dictionary of modified attributes with type-specific transformations.
+        """
+        values = super().values
+        # Convert labels set to list for JSON serialization
+        # This is necessary because:
+        # 1. The labels field is defined as a conset (constrained set) for validation
+        # 2. JSON cannot serialize Python sets directly - it only supports lists, dicts, strings, numbers, booleans, and None
+        # 3. When the effect payload is serialized to JSON in the base Effect class, it would fail with:
+        #    "TypeError: Object of type set is not JSON serializable"
+        # 4. Converting to list maintains the same data while making it JSON-compatible
+        # 5. Sort the labels to ensure consistent ordering for tests and API responses
+        if self.labels is not None:
+            values["labels"] = sorted(self.labels)
+        return values
+
     def cancel(self) -> Effect:
         """Send a CANCEL effect for the appointment."""
         self._validate_before_effect("cancel")
@@ -230,4 +274,86 @@ class Appointment(AppointmentABC):
         )
 
 
-__exports__ = ("ScheduleEvent", "Appointment")
+class _AppointmentLabelBase(_BaseEffect, TrackableFieldsModel):
+    """
+    Base class for appointment label effects.
+
+    Attributes:
+        appointment_id (UUID | str): The ID of the appointment.
+        labels (conset[str]): A set of label names (1-3 labels allowed).
+    """
+
+    appointment_id: str
+    labels: Annotated[set[str], Field(min_length=1, max_length=3)]
+
+    @property
+    def values(self) -> dict:
+        """The effect's values."""
+        result = {
+            "appointment_id": str(self.appointment_id),
+            "labels": sorted(self.labels),
+        }
+        return result
+
+
+class AddAppointmentLabel(_AppointmentLabelBase):
+    """
+    Effect to add one or more labels to an appointment.
+    """
+
+    class Meta:
+        effect_type = EffectType.ADD_APPOINTMENT_LABEL
+
+    def _get_error_details(self, method: Any) -> list[InitErrorDetails]:
+        """Validate that the appointment does not exceed the 3-label limit."""
+        errors = super()._get_error_details(method)
+
+        appointment_label_count = (
+            AppointmentDataModel.objects.filter(id=self.appointment_id)
+            .annotate(label_count=Count("labels"))
+            .values_list("label_count", flat=True)
+            .first()
+        )
+
+        # note that appointment_label_count will be None if the appointment doesn't exist
+        # and appointment_label_count will be 0 if the appointment exists but has no labels
+        if appointment_label_count is None:
+            errors.append(
+                self._create_error_detail(
+                    "value",
+                    f"Appointment {self.appointment_id} does not exist",
+                    self.appointment_id,
+                )
+            )
+        elif appointment_label_count + len(self.labels) > 3:
+            errors.append(
+                self._create_error_detail(
+                    "value",
+                    f"Limit reached: Only 3 appointment labels allowed. "
+                    f"Attempted to add {len(self.labels)} label(s) to appointment with "
+                    f"{appointment_label_count} existing label(s).",
+                    sorted(self.labels),
+                )
+            )
+        return errors
+
+
+class RemoveAppointmentLabel(_AppointmentLabelBase):
+    """
+    Effect to remove one or more labels from an appointment.
+
+    Attributes:
+        appointment_id (UUID | str): The ID of the appointment to remove labels from.
+        labels (list[str]): A list of label names to remove.
+    """
+
+    class Meta:
+        effect_type = EffectType.REMOVE_APPOINTMENT_LABEL
+
+
+__exports__ = (
+    "ScheduleEvent",
+    "Appointment",
+    "AddAppointmentLabel",
+    "RemoveAppointmentLabel",
+)

canvas_sdk/effects/note/note.py

@@ -1,9 +1,11 @@
 import datetime
+import json
 from typing import Any
 from uuid import UUID
 
 from pydantic_core import InitErrorDetails
 
+from canvas_sdk.effects import Effect
 from canvas_sdk.effects.note.base import NoteOrAppointmentABC
 from canvas_sdk.v1.data import Note as NoteModel
 from canvas_sdk.v1.data import NoteType, Patient
@@ -28,6 +30,14 @@ class Note(NoteOrAppointmentABC):
     patient_id: str | None = None
     title: str | None = None
 
+    def push_charges(self) -> Effect:
+        """Pushes BillingLineItems from the Note to the associated Claim. Identicial to clicking the Push Charges button in the note footer."""
+        self._validate_before_effect("push_charges")
+        return Effect(
+            type="PUSH_NOTE_CHARGES",
+            payload=json.dumps({"note": self.instance_id}),
+        )
+
     def _get_error_details(self, method: Any) -> list[InitErrorDetails]:
         """
         Validates the note type category and returns a list of error details if validation fails.
@@ -40,6 +50,34 @@ class Note(NoteOrAppointmentABC):
         """
         errors = super()._get_error_details(method)
 
+        if method == "push_charges":
+            if not self.instance_id:
+                errors.append(
+                    self._create_error_detail(
+                        "missing",
+                        "Field 'instance_id' is required to push charges from a note to a claim.",
+                        None,
+                    )
+                )
+            elif not (note := NoteModel.objects.filter(id=self.instance_id).first()):
+                errors.append(
+                    self._create_error_detail(
+                        "value",
+                        f"Note with ID {self.instance_id} does not exist.",
+                        self.instance_id,
+                    )
+                )
+            elif not note.note_type_version or not note.note_type_version.is_billable:
+                errors.append(
+                    self._create_error_detail(
+                        "value",
+                        f"Note with note type {note.note_type_version} is not billable and has no associated claim.",
+                        note.note_type_version,
+                    )
+                )
+
+            return errors
+
         if method == "create":
             if not self.note_type_id:
                 errors.append(

canvas_sdk/effects/task/__init__.py

@@ -1,8 +1,9 @@
-from .task import AddTask, AddTaskComment, TaskStatus, UpdateTask
+from .task import AddTask, AddTaskComment, TaskMetadata, TaskStatus, UpdateTask
 
 __all__ = __exports__ = (
     "AddTask",
     "AddTaskComment",
     "TaskStatus",
+    "TaskMetadata",
     "UpdateTask",
 )

canvas_sdk/effects/task/task.py

@@ -4,8 +4,11 @@ from typing import Any, Self, cast
 from uuid import UUID
 
 from pydantic import model_validator
+from pydantic_core import InitErrorDetails
 
 from canvas_sdk.effects.base import EffectType, _BaseEffect
+from canvas_sdk.effects.metadata import BaseMetadata
+from canvas_sdk.v1.data import Task
 
 
 class TaskStatus(Enum):
@@ -140,9 +143,36 @@ class UpdateTask(_BaseEffect):
         return value_dict
 
 
+class TaskMetadata(BaseMetadata):
+    """Task Metadata."""
+
+    class Meta:
+        effect_type = "TASK_METADATA"
+
+    task_id: str
+
+    def _get_error_details(self, method: Any) -> list[InitErrorDetails]:
+        """Get the error details for the effect.
+        If task_id is not found, return an error detail.
+        """
+        errors = super()._get_error_details(method)
+
+        if not Task.objects.filter(id=self.task_id).exists():
+            errors.append(
+                self._create_error_detail(
+                    "task_id",
+                    f"Task with id: {self.task_id} does not exist.",
+                    self.task_id,
+                )
+            )
+
+        return errors
+
+
 __exports__ = (
     "AddTask",
     "AddTaskComment",
     "TaskStatus",
+    "TaskMetadata",
     "UpdateTask",
 )

canvas_sdk/test_utils/factories/__init__.py

@@ -19,6 +19,13 @@ from .staff import (
     StaffPhotoFactory,
     StaffRoleFactory,
 )
+from .task import (
+    TaskCommentFactory,
+    TaskFactory,
+    TaskLabelFactory,
+    TaskMetadataFactory,
+    TaskTaskLabelFactory,
+)
 from .user import CanvasUserFactory
 
 __all__ = (
@@ -45,4 +52,9 @@ __all__ = (
     "StaffLicenseFactory",
     "StaffContactPointFactory",
     "StaffAddressFactory",
+    "TaskCommentFactory",
+    "TaskFactory",
+    "TaskLabelFactory",
+    "TaskMetadataFactory",
+    "TaskTaskLabelFactory",
 )