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

canvas_sdk/commands/commands/reason_for_visit.py

@@ -1,5 +1,6 @@
-from pydantic import model_validator
-from typing_extensions import Self
+from typing import Literal
+
+from pydantic_core import InitErrorDetails
 
 from canvas_sdk.commands.base import _BaseCommand
 from canvas_sdk.commands.constants import Coding
@@ -16,11 +17,17 @@ class ReasonForVisitCommand(_BaseCommand):
     coding: Coding | None = None
     comment: str | None = None
 
-    @model_validator(mode="after")
-    def _verify_structured_has_a_coding(self) -> Self:
+    def _get_error_details(
+        self, method: Literal["originate", "edit", "delete", "commit", "enter_in_error"]
+    ) -> list[InitErrorDetails]:
+        errors = super()._get_error_details(method)
         if self.structured and not self.coding:
-            raise ValueError("Structured RFV should have a coding.")
-        return self
+            errors.append(
+                self._create_error_detail(
+                    "value", f"Structured RFV should have a coding.", self.coding
+                )
+            )
+        return errors
 
     @classmethod
     def command_schema(cls) -> dict:

canvas_sdk/commands/commands/stop_medication.py

@@ -1,15 +1,19 @@
-from canvas_sdk.commands.base import _BaseCommand
 from pydantic import Field
 
+from canvas_sdk.commands.base import _BaseCommand
+
 
 class StopMedicationCommand(_BaseCommand):
     """A class for managing a StopMedication command within a specific note."""
 
     class Meta:
         key = "stopMedication"
+        originate_required_fields = ("medication_id",)
 
     # how do we make sure this is a valid medication_id for the patient?
-    medication_id: str = Field(json_schema_extra={"commands_api_name": "medication"})
+    medication_id: str | None = Field(
+        default=None, json_schema_extra={"commands_api_name": "medication"}
+    )
     rationale: str | None = None
 
     @property

canvas_sdk/commands/commands/update_goal.py

@@ -11,6 +11,7 @@ class UpdateGoalCommand(_BaseCommand):
 
     class Meta:
         key = "updateGoal"
+        originate_required_fields = ("goal_id",)
 
     class AchievementStatus(Enum):
         IN_PROGRESS = "in-progress"
@@ -28,7 +29,9 @@ class UpdateGoalCommand(_BaseCommand):
         MEDIUM = "medium-priority"
         LOW = "low-priority"
 
-    goal_id: str = Field(json_schema_extra={"commands_api_name": "goal_statement"})
+    goal_id: str | None = Field(
+        default=None, json_schema_extra={"commands_api_name": "goal_statement"}
+    )
     due_date: datetime | None = None
     achievement_status: AchievementStatus | None = None
     priority: Priority | None = None

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/data_access_layer_client.py

@@ -0,0 +1,95 @@
+"""
+Data Access Layer client.
+
+This module is primarily responsible for executing calls to the gRPC service so that such details
+are abstracted away from callers. The return values of the methods on the client class are protobufs
+which must be mapped to user-facing objects.
+"""
+
+import functools
+from collections.abc import Callable
+from types import FunctionType
+from typing import Any
+
+import grpc
+from grpc import StatusCode
+
+from canvas_generated.data_access_layer.data_access_layer_pb2 import ID, Patient
+from canvas_generated.data_access_layer.data_access_layer_pb2_grpc import (
+    DataAccessLayerStub,
+)
+from settings import DAL_TARGET
+
+from . import exceptions
+from .exceptions import DataModuleError
+
+
+class _DataAccessLayerClientMeta(type):
+    """
+    Metaclass for the Data Access Layer client class.
+
+    Wraps all methods of a class with a gRPC error handler.
+    """
+
+    def __new__(cls, name: str, bases: tuple, attrs: dict) -> type:
+        for attr_name, attr_value in attrs.items():
+            if isinstance(attr_value, FunctionType):
+                attrs[attr_name] = cls.handle_grpc_errors(attr_value)
+        return super().__new__(cls, name, bases, attrs)
+
+    @classmethod
+    def handle_grpc_errors(cls, func: Callable[..., Any]) -> Callable[..., Any]:
+        """
+        Decorator that wraps a try-except block around all class methods. gRPC errors are mapped to
+        a defined set of exceptions from a Data Access Layer exception hierarchy.
+        """
+
+        @functools.wraps(func)
+        def wrapper(*args: Any, **kwargs: Any) -> Any:
+            try:
+                return func(*args, **kwargs)
+            except grpc.RpcError as error:
+                # gRPC exceptions aren't tightly defined, so we'll try to get a status code and
+                # error details, and handle it if we can't
+                try:
+                    status_code = error.code()
+                except Exception:
+                    status_code = None
+
+                try:
+                    error_details = error.details()
+                except Exception:
+                    error_details = ""
+
+                # Map more gRPC status codes to exception types as needed
+                match status_code:
+                    case StatusCode.NOT_FOUND:
+                        raise exceptions.DataModuleNotFoundError(error_details) from error
+                    case _:
+                        raise exceptions.DataModuleError from error
+            except Exception as exception:
+                raise DataModuleError from exception
+
+        return wrapper
+
+
+class _DataAccessLayerClient(metaclass=_DataAccessLayerClientMeta):
+    """
+    Data Access Layer client.
+
+    Do not instantiate -- just import the global variable DAL_CLIENT.
+    """
+
+    def __init__(self) -> None:
+        self._channel = grpc.insecure_channel(DAL_TARGET)
+        self._stub = DataAccessLayerStub(self._channel)
+
+    def get_patient(self, id: str) -> Patient:
+        """Given an ID, get the Patient from the Data Access Layer."""
+        return self._stub.GetPatient(ID(id=id))
+
+
+# There should only be one instantiation of the client, so this global will act as a singleton in a
+# way. This is the value that should be imported; no one should be instantiating the DAL client
+# (hence the underscore notation indicating that the class is "private").
+DAL_CLIENT = _DataAccessLayerClient()