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

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
+        )

canvas_sdk/commands/tests/tests.py

@@ -1,3 +1,4 @@
+import decimal
 from datetime import datetime
 
 import pytest
@@ -20,10 +21,10 @@ from canvas_sdk.commands import (
 )
 from canvas_sdk.commands.constants import Coding
 from canvas_sdk.commands.tests.test_utils import (
+    MaskedValue,
     fake,
     get_field_type,
-    raises_missing_error,
-    raises_none_error,
+    raises_none_error_for_effect_method,
     raises_wrong_type_error,
 )
 
@@ -57,7 +58,6 @@ from canvas_sdk.commands.tests.test_utils import (
                 "icd10_codes",
                 "sig",
                 "days_supply",
-                "quantity_to_dispense",
                 "type_to_dispense",
                 "refills",
                 "substitutions",
@@ -97,15 +97,11 @@ def test_command_raises_generic_error_when_kwarg_given_incorrect_type(
     ),
     fields_to_test: tuple[str],
 ) -> None:
-    schema = Command.model_json_schema()
-    schema["required"].append("note_id")
-    required_fields = {k: v for k, v in schema["properties"].items() if k in schema["required"]}
-    base = {field: fake(props, Command) for field, props in required_fields.items()}
     for field in fields_to_test:
-        raises_wrong_type_error(base, Command, field)
-        if field in required_fields:
-            raises_missing_error(base, Command, field)
-            raises_none_error(base, Command, field)
+        raises_wrong_type_error(Command, field)
+
+    for method in ["originate", "edit", "delete", "commit", "enter_in_error"]:
+        raises_none_error_for_effect_method(Command, method)
 
 
 @pytest.mark.parametrize(
@@ -113,69 +109,101 @@ def test_command_raises_generic_error_when_kwarg_given_incorrect_type(
     [
         (
             PlanCommand,
-            {"narrative": "yo", "user_id": 1},
-            "1 validation error for PlanCommand\n  Value error, Command should have either a note_id or a command_uuid. [type=value",
-            {"narrative": "yo", "note_id": 1, "user_id": 1},
+            {"narrative": "yo", "user_id": 5, "note_uuid": 1},
+            "1 validation error for PlanCommand\nnote_uuid\n  Input should be a valid string [type=string_type",
+            {"narrative": "yo", "note_uuid": "00000000-0000-0000-0000-000000000000", "user_id": 1},
         ),
         (
             PlanCommand,
-            {"narrative": "yo", "user_id": 1, "note_id": None},
-            "1 validation error for PlanCommand\n  Value error, Command should have either a note_id or a command_uuid. [type=value",
-            {"narrative": "yo", "note_id": 1, "user_id": 1},
+            {"narrative": "yo", "user_id": 5, "note_uuid": "5", "command_uuid": 5},
+            "1 validation error for PlanCommand\ncommand_uuid\n  Input should be a valid string [type=string_type",
+            {"narrative": "yo", "user_id": 5, "note_uuid": "5", "command_uuid": "5"},
         ),
         (
             PlanCommand,
-            {"narrative": "yo", "user_id": 5, "note_id": "100"},
-            "1 validation error for PlanCommand\nnote_id\n  Input should be a valid integer [type=int_type",
-            {"narrative": "yo", "note_id": 1, "user_id": 1},
+            {"narrative": "yo", "note_uuid": "5", "command_uuid": "4", "user_id": "5"},
+            "1 validation error for PlanCommand\nuser_id\n  Input should be a valid integer [type=int_type",
+            {"narrative": "yo", "note_uuid": "5", "command_uuid": "4", "user_id": 5},
         ),
         (
             ReasonForVisitCommand,
-            {"note_id": 1, "user_id": 1, "structured": True},
-            "1 validation error for ReasonForVisitCommand\n  Value error, Structured RFV should have a coding.",
-            {"note_id": 1, "user_id": 1, "structured": False},
+            {"note_uuid": "00000000-0000-0000-0000-000000000000", "user_id": 1, "structured": True},
+            "1 validation error for ReasonForVisitCommand\n  Structured RFV should have a coding",
+            {
+                "note_uuid": "00000000-0000-0000-0000-000000000000",
+                "user_id": 1,
+                "structured": False,
+            },
         ),
         (
             ReasonForVisitCommand,
-            {"note_id": 1, "user_id": 1, "coding": {"code": "x"}},
+            {
+                "note_uuid": "00000000-0000-0000-0000-000000000000",
+                "user_id": 1,
+                "coding": {"code": "x"},
+            },
             "1 validation error for ReasonForVisitCommand\ncoding.system\n  Field required [type=missing",
-            {"note_id": 1, "user_id": 1},
+            {"note_uuid": "00000000-0000-0000-0000-000000000000", "user_id": 1},
         ),
         (
             ReasonForVisitCommand,
-            {"note_id": 1, "user_id": 1, "coding": {"code": 1, "system": "y"}},
+            {
+                "note_uuid": "00000000-0000-0000-0000-000000000000",
+                "user_id": 1,
+                "coding": {"code": 1, "system": "y"},
+            },
             "1 validation error for ReasonForVisitCommand\ncoding.code\n  Input should be a valid string [type=string_type",
-            {"note_id": 1, "user_id": 1},
+            {"note_uuid": "00000000-0000-0000-0000-000000000000", "user_id": 1},
         ),
         (
             ReasonForVisitCommand,
-            {"note_id": 1, "user_id": 1, "coding": {"code": None, "system": "y"}},
+            {
+                "note_uuid": "00000000-0000-0000-0000-000000000000",
+                "user_id": 1,
+                "coding": {"code": None, "system": "y"},
+            },
             "1 validation error for ReasonForVisitCommand\ncoding.code\n  Input should be a valid string [type=string_type",
-            {"note_id": 1, "user_id": 1},
+            {"note_uuid": "00000000-0000-0000-0000-000000000000", "user_id": 1},
         ),
         (
             ReasonForVisitCommand,
-            {"note_id": 1, "user_id": 1, "coding": {"system": "y"}},
+            {
+                "note_uuid": "00000000-0000-0000-0000-000000000000",
+                "user_id": 1,
+                "coding": {"system": "y"},
+            },
             "1 validation error for ReasonForVisitCommand\ncoding.code\n  Field required [type=missing",
-            {"note_id": 1, "user_id": 1},
+            {"note_uuid": "00000000-0000-0000-0000-000000000000", "user_id": 1},
         ),
         (
             ReasonForVisitCommand,
-            {"note_id": 1, "user_id": 1, "coding": {"code": "x", "system": 1}},
+            {
+                "note_uuid": "00000000-0000-0000-0000-000000000000",
+                "user_id": 1,
+                "coding": {"code": "x", "system": 1},
+            },
             "1 validation error for ReasonForVisitCommand\ncoding.system\n  Input should be a valid string [type=string_type",
-            {"note_id": 1, "user_id": 1},
+            {"note_uuid": "00000000-0000-0000-0000-000000000000", "user_id": 1},
         ),
         (
             ReasonForVisitCommand,
-            {"note_id": 1, "user_id": 1, "coding": {"code": "x", "system": None}},
+            {
+                "note_uuid": "00000000-0000-0000-0000-000000000000",
+                "user_id": 1,
+                "coding": {"code": "x", "system": None},
+            },
             "1 validation error for ReasonForVisitCommand\ncoding.system\n  Input should be a valid string [type=string_type",
-            {"note_id": 1, "user_id": 1},
+            {"note_uuid": "00000000-0000-0000-0000-000000000000", "user_id": 1},
         ),
         (
             ReasonForVisitCommand,
-            {"note_id": 1, "user_id": 1, "coding": {"code": "x", "system": "y", "display": 1}},
+            {
+                "note_uuid": "00000000-0000-0000-0000-000000000000",
+                "user_id": 1,
+                "coding": {"code": "x", "system": "y", "display": 1},
+            },
             "1 validation error for ReasonForVisitCommand\ncoding.display\n  Input should be a valid string [type=string_type",
-            {"note_id": 1, "user_id": 1},
+            {"note_uuid": "00000000-0000-0000-0000-000000000000", "user_id": 1},
         ),
     ],
 )
@@ -186,7 +214,9 @@ def test_command_raises_specific_error_when_kwarg_given_incorrect_type(
     valid_kwargs: dict,
 ) -> None:
     with pytest.raises(ValidationError) as e1:
-        Command(**err_kwargs)
+        cmd = Command(**err_kwargs)
+        cmd.originate()
+        cmd.edit()
     assert err_msg in repr(e1.value)
 
     cmd = Command(**valid_kwargs)
@@ -195,6 +225,8 @@ def test_command_raises_specific_error_when_kwarg_given_incorrect_type(
     key, value = list(err_kwargs.items())[-1]
     with pytest.raises(ValidationError) as e2:
         setattr(cmd, key, value)
+        cmd.originate()
+        cmd.edit()
     assert err_msg in repr(e2.value)
 
 
@@ -219,7 +251,7 @@ def test_command_raises_specific_error_when_kwarg_given_incorrect_type(
         ),
         (HistoryOfPresentIllnessCommand, ("narrative",)),
         (MedicationStatementCommand, ("fdb_code", "sig")),
-        (PlanCommand, ("narrative", "user_id", "command_uuid", "note_id")),
+        (PlanCommand, ("narrative", "user_id", "command_uuid", "note_uuid")),
         (
             PrescribeCommand,
             (
@@ -268,15 +300,12 @@ def test_command_allows_kwarg_with_correct_type(
     fields_to_test: tuple[str],
 ) -> None:
     schema = Command.model_json_schema()
-    schema["required"].append("note_id")
-    required_fields = {k: v for k, v in schema["properties"].items() if k in schema["required"]}
-    base = {field: fake(props, Command) for field, props in required_fields.items()}
 
     for field in fields_to_test:
-        field_type = get_field_type(Command.model_json_schema()["properties"][field])
+        field_type = get_field_type(schema["properties"][field])
 
         init_field_value = fake({"type": field_type}, Command)
-        init_kwargs = base | {field: init_field_value}
+        init_kwargs = {field: init_field_value}
         cmd = Command(**init_kwargs)
         assert getattr(cmd, field) == init_field_value
 
@@ -284,24 +313,37 @@ def test_command_allows_kwarg_with_correct_type(
         setattr(cmd, field, updated_field_value)
         assert getattr(cmd, field) == updated_field_value
 
+    for method in ["originate", "edit", "delete", "commit", "enter_in_error"]:
+        required_fields = {
+            k: v
+            for k, v in schema["properties"].items()
+            if k in Command()._get_effect_method_required_fields(method)
+        }
+        base = {field: fake(props, Command) for field, props in required_fields.items()}
+        cmd = Command(**base)
+        effect = getattr(cmd, method)()
+        assert effect is not None
+
 
 @pytest.fixture(scope="session")
-def token() -> str:
-    return requests.post(
-        f"{settings.INTEGRATION_TEST_URL}/auth/token/",
-        headers={"Content-Type": "application/x-www-form-urlencoded"},
-        data={
-            "grant_type": "client_credentials",
-            "client_id": settings.INTEGRATION_TEST_CLIENT_ID,
-            "client_secret": settings.INTEGRATION_TEST_CLIENT_SECRET,
-        },
-    ).json()["access_token"]
+def token() -> MaskedValue:
+    return MaskedValue(
+        requests.post(
+            f"{settings.INTEGRATION_TEST_URL}/auth/token/",
+            headers={"Content-Type": "application/x-www-form-urlencoded"},
+            data={
+                "grant_type": "client_credentials",
+                "client_id": settings.INTEGRATION_TEST_CLIENT_ID,
+                "client_secret": settings.INTEGRATION_TEST_CLIENT_SECRET,
+            },
+        ).json()["access_token"]
+    )
 
 
 @pytest.fixture
-def note_id(token: str) -> str:
+def note_uuid(token: MaskedValue) -> str:
     headers = {
-        "Authorization": f"Bearer {token}",
+        "Authorization": f"Bearer {token.value}",
         "Content-Type": "application/json",
         "Accept": "application/json",
     }
@@ -326,6 +368,9 @@ def command_type_map() -> dict[str, type]:
         "TextField": str,
         "ChoiceField": str,
         "DateField": datetime,
+        "ApproximateDateField": datetime,
+        "IntegerField": int,
+        "DecimalField": decimal.Decimal,
     }
 
 
@@ -334,14 +379,12 @@ def command_type_map() -> dict[str, type]:
     "Command",
     [
         (AssessCommand),
-        # todo: add Diagnose once it has an adapter in home-app
-        # (DiagnoseCommand),
+        (DiagnoseCommand),
         (GoalCommand),
         (HistoryOfPresentIllnessCommand),
         (MedicationStatementCommand),
         (PlanCommand),
-        # todo: add Prescribe once its been refactored
-        # (PrescribeCommand),
+        (PrescribeCommand),
         (QuestionnaireCommand),
         (ReasonForVisitCommand),
         (StopMedicationCommand),
@@ -349,9 +392,9 @@ def command_type_map() -> dict[str, type]:
     ],
 )
 def test_command_schema_matches_command_api(
-    token: str,
+    token: MaskedValue,
     command_type_map: dict[str, str],
-    note_id: str,
+    note_uuid: str,
     Command: (
         AssessCommand
         | DiagnoseCommand
@@ -367,8 +410,8 @@ def test_command_schema_matches_command_api(
     ),
 ) -> None:
     # first create the command in the new note
-    data = {"noteKey": note_id, "schemaKey": Command.Meta.key}
-    headers = {"Authorization": f"Bearer {token}"}
+    data = {"noteKey": note_uuid, "schemaKey": Command.Meta.key}
+    headers = {"Authorization": f"Bearer {token.value}"}
     url = f"{settings.INTEGRATION_TEST_URL}/core/api/v1/commands/"
     command_resp = requests.post(url, headers=headers, data=data).json()
     assert "uuid" in command_resp
@@ -396,7 +439,15 @@ def test_command_schema_matches_command_api(
         expected_type = expected_field["type"]
         if expected_type is Coding:
             expected_type = expected_type.__annotations__["code"]
-        assert expected_type == command_type_map.get(actual_field["type"])
+
+        actual_type = command_type_map.get(actual_field["type"])
+        if actual_field["type"] == "AutocompleteField" and name[-1] == "s":
+            # this condition initially created for Prescribe.indications,
+            # but could apply to other AutocompleteField fields that are lists
+            # making the assumption here that if the field ends in 's' (like indications), it is a list
+            actual_type = list[actual_type]  # type: ignore
+
+        assert expected_type == actual_type
 
         if (choices := actual_field["choices"]) is None:
             assert expected_field["choices"] is None

canvas_sdk/data/__init__.py

@@ -0,0 +1 @@
+from .base import DataModel

canvas_sdk/data/base.py

@@ -0,0 +1,22 @@
+from pydantic_core import ValidationError
+
+from canvas_sdk.base import Model
+
+
+class DataModel(Model):
+    class Meta:
+        update_required_fields = ("id",)
+
+    def model_dump_json_nested(self, *args, **kwargs) -> str:
+        """
+        Returns the model's json representation nested in a {"data": {..}} key.
+        """
+        return f'{{"data": {self.model_dump_json(*args, **kwargs)}}}'
+
+    def _validate_before_effect(self, method: str) -> None:
+        if method == "create" and getattr(self, "id", None):
+            error = self._create_error_detail(
+                "value", "create cannot be called on a model with an id", "id"
+            )
+            raise ValidationError.from_exception_data(self.__class__.__name__, [error])
+        super()._validate_before_effect(method)

canvas_sdk/data/patient.py

@@ -0,0 +1,6 @@
+from canvas_sdk.data import DataModel
+
+
+class Patient(DataModel):
+    id: str | None = None
+    # TODO - populate more attributes

canvas_sdk/data/staff.py

@@ -0,0 +1,6 @@
+from canvas_sdk.data import DataModel
+
+
+class Staff(DataModel):
+    id: str | None = None
+    # TODO - populate with first name, last name, additional attributes, etc.

canvas_sdk/data/task.py

@@ -0,0 +1,60 @@
+from datetime import datetime
+from enum import Enum
+
+from canvas_sdk.data import DataModel
+from canvas_sdk.data.patient import Patient
+from canvas_sdk.data.staff import Staff
+from canvas_sdk.effects import Effect, EffectType
+
+
+class Task(DataModel):
+    class Meta(DataModel.Meta):
+        create_required_fields = ("title",)
+
+    class Status(Enum):
+        COMPLETED = "Completed"
+        CLOSED = "Closed"
+        OPEN = "Open"
+
+    id: str | None = None
+    assignee: Staff | None = None
+    patient: Patient | None = None
+    title: str | None = None
+    due: datetime | None = None
+    status: Status | None = None
+    comments: "list[TaskComment] | None" = None
+    labels: list[str] | None = None
+
+    def create(self) -> Effect:
+        self._validate_before_effect("create")
+        return Effect(type=EffectType.CREATE_TASK, payload=self.model_dump_json_nested())
+
+    def update(self) -> Effect:
+        self._validate_before_effect("update")
+        payload = self.model_dump_json_nested(exclude_unset=True)
+        return Effect(type=EffectType.UPDATE_TASK, payload=payload)
+
+    def add_comment(self, comment: str) -> Effect:
+        if not self.id:
+            raise ValueError("Cannot add a comment to a Task without an id")
+        task_comment = TaskComment(task=self, body=comment)
+        task_comment._validate_before_effect("create")
+        return Effect(
+            type=EffectType.CREATE_TASK_COMMENT,
+            payload=task_comment.model_dump_json_nested(exclude_unset=True),
+        )
+
+
+class TaskComment(DataModel):
+    class Meta:
+        create_required_fields = (
+            "body",
+            "task",
+        )
+
+    id: str | None = None
+    task: Task | None = None
+    body: str | None = None
+
+
+Task.model_rebuild()

canvas_sdk/effects/__init__.py

@@ -1 +1 @@
-from generated.messages.effects_pb2 import Effect, EffectType
+from canvas_generated.messages.effects_pb2 import Effect, EffectType

canvas_sdk/effects/banner_alert/__init__.py

@@ -0,0 +1,2 @@
+from canvas_sdk.effects.banner_alert.add_banner_alert import AddBannerAlert
+from canvas_sdk.effects.banner_alert.remove_banner_alert import RemoveBannerAlert

canvas_sdk/effects/banner_alert/add_banner_alert.py

@@ -0,0 +1,49 @@
+from enum import Enum
+from typing import Any
+
+from pydantic import Field
+
+from canvas_sdk.effects.base import EffectType, _BaseEffect
+
+
+class AddBannerAlert(_BaseEffect):
+    """
+    An Effect that will result in a banner alert in Canvas.
+    """
+
+    class Meta:
+        effect_type = EffectType.ADD_BANNER_ALERT
+
+    class Placement(Enum):
+        CHART = "chart"
+        TIMELINE = "timeline"
+        APPOINTMENT_CARD = "appointment_card"
+        SCHEDULING_CARD = "scheduling_card"
+        PROFILE = "profile"
+
+    class Intent(Enum):
+        INFO = "info"
+        WARNING = "warning"
+        ALERT = "alert"
+
+    patient_id: str
+    key: str
+    narrative: str = Field(max_length=90)
+    placement: list[Placement] = Field(min_length=1)
+    intent: Intent
+    href: str | None = None
+
+    @property
+    def values(self) -> dict[str, Any]:
+        """The BannerAlert's values."""
+        return {
+            "narrative": self.narrative,
+            "placement": [p.value for p in self.placement],
+            "intent": self.intent.value,
+            "href": self.href,
+        }
+
+    @property
+    def effect_payload(self) -> dict[str, Any]:
+        """The payload of the effect."""
+        return {"patient": self.patient_id, "key": self.key, "data": self.values}

canvas_sdk/effects/banner_alert/remove_banner_alert.py

@@ -0,0 +1,20 @@
+from typing import Any
+
+from canvas_sdk.effects.base import EffectType, _BaseEffect
+
+
+class RemoveBannerAlert(_BaseEffect):
+    """
+    An Effect that will remove/inactivate a banner alert in Canvas.
+    """
+
+    class Meta:
+        effect_type = EffectType.REMOVE_BANNER_ALERT
+
+    patient_id: str
+    key: str
+
+    @property
+    def effect_payload(self) -> dict[str, Any]:
+        """The payload of the effect."""
+        return {"patient": self.patient_id, "key": self.key}