canvas 0.2.5__py3-none-any.whl → 0.2.11__py3-none-any.whl

canvas_sdk/commands/tests/{tests.py → unit/tests.py}

@@ -1,11 +1,7 @@
-import decimal
-from datetime import datetime
-
 import pytest
-import requests
 from pydantic import ValidationError
+from typer.testing import CliRunner
 
-import settings
 from canvas_sdk.commands import (
     AssessCommand,
     DiagnoseCommand,
@@ -19,15 +15,16 @@ from canvas_sdk.commands import (
     StopMedicationCommand,
     UpdateGoalCommand,
 )
-from canvas_sdk.commands.constants import Coding
+from canvas_sdk.commands.base import _BaseCommand
 from canvas_sdk.commands.tests.test_utils import (
-    MaskedValue,
     fake,
     get_field_type,
     raises_none_error_for_effect_method,
     raises_wrong_type_error,
 )
 
+runner = CliRunner()
+
 
 @pytest.mark.parametrize(
     "Command,fields_to_test",
@@ -50,7 +47,7 @@ from canvas_sdk.commands.tests.test_utils import (
         ),
         (HistoryOfPresentIllnessCommand, ("narrative",)),
         (MedicationStatementCommand, ("fdb_code", "sig")),
-        (PlanCommand, ("narrative", "user_id", "command_uuid")),
+        (PlanCommand, ("narrative", "command_uuid")),
         (
             PrescribeCommand,
             (
@@ -82,19 +79,7 @@ from canvas_sdk.commands.tests.test_utils import (
     ],
 )
 def test_command_raises_generic_error_when_kwarg_given_incorrect_type(
-    Command: (
-        AssessCommand
-        | DiagnoseCommand
-        | GoalCommand
-        | HistoryOfPresentIllnessCommand
-        | MedicationStatementCommand
-        | PlanCommand
-        | PrescribeCommand
-        | QuestionnaireCommand
-        | ReasonForVisitCommand
-        | StopMedicationCommand
-        | UpdateGoalCommand
-    ),
+    Command: _BaseCommand,
     fields_to_test: tuple[str],
 ) -> None:
     for field in fields_to_test:
@@ -109,29 +94,22 @@ def test_command_raises_generic_error_when_kwarg_given_incorrect_type(
     [
         (
             PlanCommand,
-            {"narrative": "yo", "user_id": 5, "note_uuid": 1},
+            {"narrative": "yo", "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},
+            {"narrative": "yo", "note_uuid": "00000000-0000-0000-0000-000000000000"},
         ),
         (
             PlanCommand,
-            {"narrative": "yo", "user_id": 5, "note_uuid": "5", "command_uuid": 5},
+            {"narrative": "yo", "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", "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},
+            {"narrative": "yo", "note_uuid": "5", "command_uuid": "5"},
         ),
         (
             ReasonForVisitCommand,
-            {"note_uuid": "00000000-0000-0000-0000-000000000000", "user_id": 1, "structured": True},
+            {"note_uuid": "00000000-0000-0000-0000-000000000000", "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,
             },
         ),
@@ -139,71 +117,64 @@ def test_command_raises_generic_error_when_kwarg_given_incorrect_type(
             ReasonForVisitCommand,
             {
                 "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_uuid": "00000000-0000-0000-0000-000000000000", "user_id": 1},
+            {"note_uuid": "00000000-0000-0000-0000-000000000000"},
         ),
         (
             ReasonForVisitCommand,
             {
                 "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_uuid": "00000000-0000-0000-0000-000000000000", "user_id": 1},
+            {"note_uuid": "00000000-0000-0000-0000-000000000000"},
         ),
         (
             ReasonForVisitCommand,
             {
                 "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_uuid": "00000000-0000-0000-0000-000000000000", "user_id": 1},
+            {"note_uuid": "00000000-0000-0000-0000-000000000000"},
         ),
         (
             ReasonForVisitCommand,
             {
                 "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_uuid": "00000000-0000-0000-0000-000000000000", "user_id": 1},
+            {"note_uuid": "00000000-0000-0000-0000-000000000000"},
         ),
         (
             ReasonForVisitCommand,
             {
                 "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_uuid": "00000000-0000-0000-0000-000000000000", "user_id": 1},
+            {"note_uuid": "00000000-0000-0000-0000-000000000000"},
         ),
         (
             ReasonForVisitCommand,
             {
                 "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_uuid": "00000000-0000-0000-0000-000000000000", "user_id": 1},
+            {"note_uuid": "00000000-0000-0000-0000-000000000000"},
         ),
         (
             ReasonForVisitCommand,
             {
                 "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_uuid": "00000000-0000-0000-0000-000000000000", "user_id": 1},
+            {"note_uuid": "00000000-0000-0000-0000-000000000000"},
         ),
     ],
 )
@@ -251,7 +222,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_uuid")),
+        (PlanCommand, ("narrative", "command_uuid", "note_uuid")),
         (
             PrescribeCommand,
             (
@@ -284,19 +255,7 @@ def test_command_raises_specific_error_when_kwarg_given_incorrect_type(
     ],
 )
 def test_command_allows_kwarg_with_correct_type(
-    Command: (
-        AssessCommand
-        | DiagnoseCommand
-        | GoalCommand
-        | HistoryOfPresentIllnessCommand
-        | MedicationStatementCommand
-        | PlanCommand
-        | PrescribeCommand
-        | QuestionnaireCommand
-        | ReasonForVisitCommand
-        | StopMedicationCommand
-        | UpdateGoalCommand
-    ),
+    Command: _BaseCommand,
     fields_to_test: tuple[str],
 ) -> None:
     schema = Command.model_json_schema()
@@ -323,136 +282,3 @@ def test_command_allows_kwarg_with_correct_type(
         cmd = Command(**base)
         effect = getattr(cmd, method)()
         assert effect is not None
-
-
-@pytest.fixture(scope="session")
-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_uuid(token: MaskedValue) -> str:
-    headers = {
-        "Authorization": f"Bearer {token.value}",
-        "Content-Type": "application/json",
-        "Accept": "application/json",
-    }
-    data = {
-        "patient": 1,
-        "provider": 1,
-        "note_type": "office",
-        "note_type_version": 1,
-        "lastModifiedBySessionKey": "8fee3c03a525cebee1d8a6b8e63dd4dg",
-    }
-    note = requests.post(
-        f"{settings.INTEGRATION_TEST_URL}/api/Note/", headers=headers, json=data
-    ).json()
-    return note["externallyExposableId"]
-
-
-@pytest.fixture
-def command_type_map() -> dict[str, type]:
-    return {
-        "AutocompleteField": str,
-        "MultiLineTextField": str,
-        "TextField": str,
-        "ChoiceField": str,
-        "DateField": datetime,
-        "ApproximateDateField": datetime,
-        "IntegerField": int,
-        "DecimalField": decimal.Decimal,
-    }
-
-
-@pytest.mark.integtest
-@pytest.mark.parametrize(
-    "Command",
-    [
-        (AssessCommand),
-        (DiagnoseCommand),
-        (GoalCommand),
-        (HistoryOfPresentIllnessCommand),
-        (MedicationStatementCommand),
-        (PlanCommand),
-        (PrescribeCommand),
-        (QuestionnaireCommand),
-        (ReasonForVisitCommand),
-        (StopMedicationCommand),
-        (UpdateGoalCommand),
-    ],
-)
-def test_command_schema_matches_command_api(
-    token: MaskedValue,
-    command_type_map: dict[str, str],
-    note_uuid: str,
-    Command: (
-        AssessCommand
-        | DiagnoseCommand
-        | GoalCommand
-        | HistoryOfPresentIllnessCommand
-        | MedicationStatementCommand
-        | PlanCommand
-        | PrescribeCommand
-        | QuestionnaireCommand
-        | ReasonForVisitCommand
-        | StopMedicationCommand
-        | UpdateGoalCommand
-    ),
-) -> None:
-    # first create the command in the new note
-    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
-    command_uuid = command_resp["uuid"]
-
-    # next, request the fields of the newly created command
-    url = f"{settings.INTEGRATION_TEST_URL}/core/api/v1/commands/{command_uuid}/fields/"
-    command_fields_resp = requests.get(url, headers=headers).json()
-    assert command_fields_resp["schema"] == Command.Meta.key
-
-    command_fields = command_fields_resp["fields"]
-    if Command.Meta.key == "questionnaire":
-        # questionnaire's fields vary per questionnaire, so just check the first two fields which never vary
-        command_fields = command_fields[:2]
-    expected_fields = Command.command_schema()
-    assert len(command_fields) == len(expected_fields)
-
-    for actual_field in command_fields:
-        name = actual_field["name"]
-        assert name in expected_fields
-        expected_field = expected_fields[name]
-
-        assert expected_field["required"] == actual_field["required"]
-
-        expected_type = expected_field["type"]
-        if expected_type is Coding:
-            expected_type = expected_type.__annotations__["code"]
-
-        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
-            continue
-
-        assert len(expected_field["choices"]) == len(choices)
-        for choice in choices:
-            assert choice["value"] in expected_field["choices"]

canvas_sdk/effects/banner_alert/add_banner_alert.py

@@ -13,6 +13,7 @@ class AddBannerAlert(_BaseEffect):
 
     class Meta:
         effect_type = EffectType.ADD_BANNER_ALERT
+        apply_required_fields = ("patient_id", "key", "narrative", "placement", "intent")
 
     class Placement(Enum):
         CHART = "chart"
@@ -26,11 +27,11 @@ class AddBannerAlert(_BaseEffect):
         WARNING = "warning"
         ALERT = "alert"
 
-    patient_id: str
-    key: str
-    narrative: str = Field(max_length=90)
-    placement: list[Placement] = Field(min_length=1)
-    intent: Intent
+    patient_id: str | None = None
+    key: str | None = None
+    narrative: str | None = Field(max_length=90, default=None)
+    placement: list[Placement] | None = Field(min_length=1, default=None)
+    intent: Intent | None = None
     href: str | None = None
 
     @property
@@ -38,8 +39,8 @@ class AddBannerAlert(_BaseEffect):
         """The BannerAlert's values."""
         return {
             "narrative": self.narrative,
-            "placement": [p.value for p in self.placement],
-            "intent": self.intent.value,
+            "placement": [p.value for p in self.placement] if self.placement else None,
+            "intent": self.intent.value if self.intent else None,
             "href": self.href,
         }
 

canvas_sdk/effects/banner_alert/remove_banner_alert.py

@@ -10,9 +10,10 @@ class RemoveBannerAlert(_BaseEffect):
 
     class Meta:
         effect_type = EffectType.REMOVE_BANNER_ALERT
+        apply_required_fields = ("patient_id", "key")
 
-    patient_id: str
-    key: str
+    patient_id: str | None = None
+    key: str | None = None
 
     @property
     def effect_payload(self) -> dict[str, Any]:

canvas_sdk/effects/banner_alert/tests.py

@@ -0,0 +1,224 @@
+import shutil
+from contextlib import chdir
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Generator
+
+import pytest
+import requests
+from pydantic import ValidationError
+from typer.testing import CliRunner
+
+import settings
+from canvas_cli.apps.plugin.plugin import _build_package, plugin_url
+from canvas_cli.main import app
+from canvas_sdk.commands.tests.test_utils import MaskedValue
+from canvas_sdk.effects.banner_alert import AddBannerAlert, RemoveBannerAlert
+
+runner = CliRunner()
+
+
+@pytest.fixture(scope="session")
+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(scope="session")
+def first_patient_id(token: MaskedValue) -> dict:
+    headers = {
+        "Authorization": f"Bearer {token.value}",
+        "Content-Type": "application/json",
+        "Accept": "application/json",
+    }
+    patients = requests.get(f"{settings.INTEGRATION_TEST_URL}/api/Patient", headers=headers).json()
+    return patients["entry"][0]["resource"]["key"]
+
+
+@pytest.fixture(scope="session")
+def plugin_name() -> str:
+    return f"addbanneralert{datetime.now().timestamp()}".replace(".", "")
+
+
+@pytest.fixture(autouse=True, scope="session")
+def write_and_install_protocol_and_clean_up(
+    first_patient_id: str, plugin_name: str, token: MaskedValue
+) -> Generator[Any, Any, Any]:
+    # write the protocol
+    with chdir(Path("./custom-plugins")):
+        runner.invoke(app, "init", input=plugin_name)
+
+    protocol = open(f"./custom-plugins/{plugin_name}/protocols/my_protocol.py", "w")
+    protocol.write(
+        f"""from canvas_sdk.effects.banner_alert import AddBannerAlert
+from canvas_sdk.events import EventType
+from canvas_sdk.protocols import BaseProtocol
+
+class Protocol(BaseProtocol):
+    RESPONDS_TO = EventType.Name(EventType.ENCOUNTER_CREATED)
+    def compute(self):
+        return [
+            AddBannerAlert(
+                patient_id="{first_patient_id}",
+                key="{plugin_name}",
+                narrative="this is a test",
+                placement=[AddBannerAlert.Placement.CHART],
+                intent=AddBannerAlert.Intent.INFO,
+            ).apply()
+        ]
+"""
+    )
+    protocol.close()
+
+    # install the plugin
+    requests.post(
+        plugin_url(settings.INTEGRATION_TEST_URL),
+        data={"is_enabled": True},
+        files={"package": open(_build_package(Path(f"./custom-plugins/{plugin_name}")), "rb")},
+        headers={"Authorization": f"Bearer {token.value}"},
+    )
+
+    yield
+
+    # clean up
+    if Path(f"./custom-plugins/{plugin_name}").exists():
+        shutil.rmtree(Path(f"./custom-plugins/{plugin_name}"))
+
+    # disable
+    requests.patch(
+        plugin_url(settings.INTEGRATION_TEST_URL, plugin_name),
+        data={"is_enabled": False},
+        headers={
+            "Authorization": f"Bearer {token.value}",
+        },
+    )
+    # delete
+    requests.delete(
+        plugin_url(settings.INTEGRATION_TEST_URL, plugin_name),
+        headers={"Authorization": f"Bearer {token.value}"},
+    )
+
+    # confirm no more banner
+    patient_banners_none = requests.get(
+        f"{settings.INTEGRATION_TEST_URL}/api/BannerAlert/?patient__key={first_patient_id}",
+        headers={
+            "Authorization": f"Bearer {token.value}",
+        },
+    ).json()
+    patient_banner = next(
+        (b for b in patient_banners_none["results"] if b["key"] == plugin_name), None
+    )
+    assert patient_banner is None
+
+
+@pytest.mark.integtest
+def test_protocol_that_adds_banner_alert(
+    token: MaskedValue, plugin_name: str, first_patient_id: str
+) -> None:
+    # trigger the event
+    requests.post(
+        f"{settings.INTEGRATION_TEST_URL}/api/Note/",
+        headers={
+            "Authorization": f"Bearer {token.value}",
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+        },
+        json={
+            "patient": 1,
+            "provider": 1,
+            "note_type": "office",
+            "note_type_version": 1,
+            "lastModifiedBySessionKey": "8fee3c03a525cebee1d8a6b8e63dd4dg",
+        },
+    )
+
+    patient_banners = requests.get(
+        f"{settings.INTEGRATION_TEST_URL}/api/BannerAlert/?patient__key={first_patient_id}",
+        headers={
+            "Authorization": f"Bearer {token.value}",
+        },
+    ).json()
+    assert patient_banners["count"] > 0
+
+    patient_banner = next(b for b in patient_banners["results"] if b["key"] == plugin_name)
+    assert patient_banner["pluginName"] == plugin_name
+    assert patient_banner["narrative"] == "this is a test"
+    assert patient_banner["placement"] == ["chart"]
+    assert patient_banner["intent"] == "info"
+    assert patient_banner["href"] is None
+    assert patient_banner["status"] == "active"
+
+
+@pytest.mark.parametrize(
+    "Effect,params,expected_payload",
+    [
+        (
+            AddBannerAlert,
+            {
+                "patient_id": "uuid",
+                "key": "test-key",
+                "narrative": "hellooo",
+                "placement": [AddBannerAlert.Placement.APPOINTMENT_CARD],
+                "intent": AddBannerAlert.Intent.INFO,
+            },
+            '{"patient": "uuid", "key": "test-key", "data": {"narrative": "hellooo", "placement": ["appointment_card"], "intent": "info", "href": null}}',
+        ),
+        (
+            RemoveBannerAlert,
+            {"patient_id": "uuid", "key": "testeroo"},
+            '{"patient": "uuid", "key": "testeroo"}',
+        ),
+    ],
+)
+def test_banner_alert_apply_method_succeeds_with_all_required_fields(
+    Effect: AddBannerAlert | RemoveBannerAlert, params: dict, expected_payload: str
+) -> None:
+    b = Effect()
+    for k, v in params.items():
+        setattr(b, k, v)
+    applied = b.apply()
+    assert applied.payload == expected_payload
+
+
+@pytest.mark.parametrize(
+    "Effect,expected_err_msgs",
+    [
+        (
+            AddBannerAlert,
+            [
+                "5 validation errors for AddBannerAlert",
+                "Field 'patient_id' is required to apply an AddBannerAlert [type=missing",
+                "Field 'key' is required to apply an AddBannerAlert [type=missing",
+                "Field 'narrative' is required to apply an AddBannerAlert [type=missing",
+                "Field 'placement' is required to apply an AddBannerAlert [type=missing",
+                "Field 'intent' is required to apply an AddBannerAlert [type=missing",
+            ],
+        ),
+        (
+            RemoveBannerAlert,
+            [
+                "2 validation errors for RemoveBannerAlert",
+                "Field 'patient_id' is required to apply a RemoveBannerAlert [type=missing",
+                "Field 'key' is required to apply a RemoveBannerAlert [type=missing",
+            ],
+        ),
+    ],
+)
+def test_banner_alert_apply_method_raises_error_without_required_fields(
+    Effect: AddBannerAlert | RemoveBannerAlert, expected_err_msgs: str
+) -> None:
+    b = Effect()
+    with pytest.raises(ValidationError) as e:
+        b.apply()
+    err_msg = repr(e.value)
+    for expected in expected_err_msgs:
+        assert expected in err_msg

canvas_sdk/effects/base.py

@@ -1,12 +1,11 @@
 import json
 from typing import Any
 
-from pydantic import BaseModel, ConfigDict
-
+from canvas_sdk.base import Model
 from canvas_sdk.effects import Effect, EffectType
 
 
-class _BaseEffect(BaseModel):
+class _BaseEffect(Model):
     """
     A Canvas Effect that changes user behavior or autonomously performs activities on behalf of users.
     """
@@ -14,8 +13,6 @@ class _BaseEffect(BaseModel):
     class Meta:
         effect_type = EffectType.UNKNOWN_EFFECT
 
-    model_config = ConfigDict(strict=True, validate_assignment=True)
-
     @property
     def values(self) -> dict[str, Any]:
         return {}
@@ -25,4 +22,5 @@ class _BaseEffect(BaseModel):
         return {"data": self.values}
 
     def apply(self) -> Effect:
+        self._validate_before_effect("apply")
         return Effect(type=self.Meta.effect_type, payload=json.dumps(self.effect_payload))

canvas_sdk/effects/patient_chart_summary_configuration.py

@@ -0,0 +1,39 @@
+from enum import Enum
+from typing import Any
+
+from pydantic import Field
+
+from canvas_sdk.effects.base import EffectType, _BaseEffect
+
+
+class PatientChartSummaryConfiguration(_BaseEffect):
+    """
+    An Effect that will decide which sections appear on the patient's chart summary in Canvas.
+    """
+
+    class Meta:
+        effect_type = EffectType.SHOW_PATIENT_CHART_SUMMARY_SECTIONS
+
+    class Section(Enum):
+        SOCIAL_DETERMINANTS = "social_determinants"
+        GOALS = "goals"
+        CONDITIONS = "conditions"
+        MEDICATIONS = "medications"
+        ALLERGIES = "allergies"
+        CARE_TEAMS = "care_teams"
+        VITALS = "vitals"
+        IMMUNIZATIONS = "immunizations"
+        SURGICAL_HISTORY = "surgical_history"
+        FAMILY_HISTORY = "family_history"
+
+    sections: list[Section] = Field(min_length=1)
+
+    @property
+    def values(self) -> dict[str, Any]:
+        """The PatientChartSummaryConfiguration's values."""
+        return {"sections": [s.value for s in self.sections]}
+
+    @property
+    def effect_payload(self) -> dict[str, Any]:
+        """The payload of the effect."""
+        return {"data": self.values}

canvas_sdk/effects/protocol_card/__init__.py

@@ -0,0 +1 @@
+from canvas_sdk.effects.protocol_card.protocol_card import ProtocolCard, Recommendation