canvas 0.17.0__py3-none-any.whl → 0.19.0__py3-none-any.whl

canvas_sdk/commands/tests/test_utils.py

@@ -37,6 +37,12 @@ from canvas_sdk.commands.constants import ClinicalQuantity, Coding
 runner = CliRunner()
 
 
+class WrongType:
+    """A type to yield ValidationErrors in tests."""
+
+    wrong_field: str
+
+
 class MaskedValue:
     """A class to mask sensitive values in tests."""
 
@@ -97,6 +103,8 @@ def fake(field_props: dict, Command: type[_BaseCommand]) -> Any:
             return Coding(system=random_string(), code=random_string(), display=random_string())
         case "ClinicalQuantity":
             return ClinicalQuantity(representative_ndc="ndc", ncpdp_quantity_qualifier_code="code")
+        case "WrongType":
+            return WrongType()
     if t[0].isupper():
         return random.choice(list(getattr(Command, t)))
 
@@ -108,7 +116,8 @@ def raises_wrong_type_error(
     """Test that the correct error is raised when the wrong type is passed to a field."""
     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"
+
+    wrong_field_type = "WrongType"
 
     with pytest.raises(ValidationError) as e1:
         err_kwargs = {field: fake({"type": wrong_field_type}, Command)}
@@ -122,8 +131,11 @@ def raises_wrong_type_error(
         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
+    assert "validation error" in err_msg1
+    assert f"{Command.__name__}\n{field}" in err_msg1
+
+    assert "validation error" in err_msg2
+    assert f"{Command.__name__}\n{field}" in err_msg1
 
     field_type = (
         "dictionary" if field_type == "Coding" or field_type == "ClinicalQuantity" else field_type

canvas_sdk/commands/tests/unit/tests.py

@@ -1,3 +1,5 @@
+import uuid
+
 import pytest
 from pydantic import ValidationError
 from typer.testing import CliRunner
@@ -91,24 +93,21 @@ def test_command_raises_generic_error_when_kwarg_given_incorrect_type(
 
 
 @pytest.mark.parametrize(
-    "Command,err_kwargs,err_msg,valid_kwargs",
+    "Command,err_kwargs,valid_kwargs",
     [
         (
             PlanCommand,
             {"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"},
         ),
         (
             PlanCommand,
             {"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", "note_uuid": "5", "command_uuid": "5"},
         ),
         (
             ReasonForVisitCommand,
             {"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",
                 "structured": False,
@@ -120,7 +119,6 @@ def test_command_raises_generic_error_when_kwarg_given_incorrect_type(
                 "note_uuid": "00000000-0000-0000-0000-000000000000",
                 "coding": {"code": "x"},
             },
-            "1 validation error for ReasonForVisitCommand\ncoding.system\n  Field required [type=missing",
             {"note_uuid": "00000000-0000-0000-0000-000000000000"},
         ),
         (
@@ -129,7 +127,6 @@ def test_command_raises_generic_error_when_kwarg_given_incorrect_type(
                 "note_uuid": "00000000-0000-0000-0000-000000000000",
                 "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"},
         ),
         (
@@ -138,7 +135,6 @@ def test_command_raises_generic_error_when_kwarg_given_incorrect_type(
                 "note_uuid": "00000000-0000-0000-0000-000000000000",
                 "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"},
         ),
         (
@@ -147,7 +143,6 @@ def test_command_raises_generic_error_when_kwarg_given_incorrect_type(
                 "note_uuid": "00000000-0000-0000-0000-000000000000",
                 "coding": {"system": "y"},
             },
-            "1 validation error for ReasonForVisitCommand\ncoding.code\n  Field required [type=missing",
             {"note_uuid": "00000000-0000-0000-0000-000000000000"},
         ),
         (
@@ -156,7 +151,6 @@ def test_command_raises_generic_error_when_kwarg_given_incorrect_type(
                 "note_uuid": "00000000-0000-0000-0000-000000000000",
                 "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"},
         ),
         (
@@ -165,7 +159,6 @@ def test_command_raises_generic_error_when_kwarg_given_incorrect_type(
                 "note_uuid": "00000000-0000-0000-0000-000000000000",
                 "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"},
         ),
         (
@@ -174,7 +167,6 @@ def test_command_raises_generic_error_when_kwarg_given_incorrect_type(
                 "note_uuid": "00000000-0000-0000-0000-000000000000",
                 "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"},
         ),
     ],
@@ -182,25 +174,24 @@ def test_command_raises_generic_error_when_kwarg_given_incorrect_type(
 def test_command_raises_specific_error_when_kwarg_given_incorrect_type(
     Command: type[PlanCommand] | type[ReasonForVisitCommand],
     err_kwargs: dict,
-    err_msg: str,
     valid_kwargs: dict,
 ) -> None:
     """Test that Command raises a specific error when a kwarg is given an incorrect type."""
-    with pytest.raises(ValidationError) as e1:
+    with pytest.raises(ValidationError):
         cmd = Command(**err_kwargs)
         cmd.originate()
+        cmd.command_uuid = str(uuid.uuid4())
         cmd.edit()
-    assert err_msg in repr(e1.value)
 
     cmd = Command(**valid_kwargs)
     if len(err_kwargs) < len(valid_kwargs):
         return
     key, value = list(err_kwargs.items())[-1]
-    with pytest.raises(ValidationError) as e2:
+    with pytest.raises(ValidationError):
         setattr(cmd, key, value)
         cmd.originate()
+        cmd.command_uuid = str(uuid.uuid4())
         cmd.edit()
-    assert err_msg in repr(e2.value)
 
 
 @pytest.mark.parametrize(

canvas_sdk/effects/surescripts/__init__.py

@@ -0,0 +1,11 @@
+from .surescripts_messages import (
+    SendSurescriptsBenefitsRequestEffect,
+    SendSurescriptsEligibilityRequestEffect,
+    SendSurescriptsMedicationHistoryRequestEffect,
+)
+
+__all__ = [
+    "SendSurescriptsBenefitsRequestEffect",
+    "SendSurescriptsEligibilityRequestEffect",
+    "SendSurescriptsMedicationHistoryRequestEffect",
+]

canvas_sdk/effects/task/__init__.py

@@ -0,0 +1,3 @@
+from .task import AddTask, AddTaskComment, TaskStatus, UpdateTask
+
+__all__ = ["AddTask", "AddTaskComment", "TaskStatus", "UpdateTask"]

canvas_sdk/effects/task/task.py

@@ -23,6 +23,7 @@ class AddTask(_BaseEffect):
         apply_required_fields = ("title",)
 
     assignee_id: str | None = None
+    team_id: str | None = None
     patient_id: str | None = None
     title: str | None = None
     due: datetime | None = None
@@ -36,6 +37,7 @@ class AddTask(_BaseEffect):
             "patient": {"id": self.patient_id},
             "due": self.due.isoformat() if self.due else None,
             "assignee": {"id": self.assignee_id},
+            "team": {"id": self.team_id},
             "title": self.title,
             "status": self.status.value,
             "labels": self.labels,
@@ -74,6 +76,7 @@ class UpdateTask(_BaseEffect):
 
     id: str | None = None
     assignee_id: str | None = None
+    team_id: str | None = None
     patient_id: str | None = None
     title: str | None = None
     due: datetime | None = None

canvas_sdk/questionnaires/__init__.py

@@ -0,0 +1,3 @@
+from .utils import from_yaml as questionnaire_from_yaml
+
+__all__ = ("questionnaire_from_yaml",)

canvas_sdk/questionnaires/tests/test_utils.py

@@ -0,0 +1,74 @@
+import json
+from pathlib import Path
+
+import pytest
+import yaml
+
+from canvas_sdk.effects import Effect
+from canvas_sdk.events import Event, EventRequest, EventType
+from canvas_sdk.questionnaires import questionnaire_from_yaml
+from plugin_runner.plugin_runner import LOADED_PLUGINS
+from settings import PLUGIN_DIRECTORY
+
+
+@pytest.mark.parametrize("install_test_plugin", ["test_load_questionnaire"], indirect=True)
+def test_from_yaml_valid_questionnaire(install_test_plugin: Path, load_test_plugins: None) -> None:
+    """Test that the from_yaml function loads a valid questionnaire."""
+    plugin = LOADED_PLUGINS[
+        "test_load_questionnaire:test_load_questionnaire.protocols.my_protocol:ValidQuestionnaire"
+    ]
+    result: list[Effect] = plugin["class"](Event(EventRequest(type=EventType.UNKNOWN))).compute()
+
+    assert (
+        yaml.load(
+            (
+                Path(PLUGIN_DIRECTORY)
+                / "test_load_questionnaire/questionnaires/example_questionnaire.yml"
+            )
+            .resolve()
+            .read_text(),
+            Loader=yaml.SafeLoader,
+        ).items()
+        <= json.loads(result[0].payload).items()
+    )
+
+
+@pytest.mark.parametrize("install_test_plugin", ["test_load_questionnaire"], indirect=True)
+def test_from_yaml_invalid_questionnaire(
+    install_test_plugin: Path, load_test_plugins: None
+) -> None:
+    """Test that the from_yaml function raises an error for invalid questionnaires."""
+    plugin = LOADED_PLUGINS[
+        "test_load_questionnaire:test_load_questionnaire.protocols.my_protocol:InvalidQuestionnaire"
+    ]
+    with pytest.raises(FileNotFoundError):
+        plugin["class"](Event(EventRequest(type=EventType.UNKNOWN))).compute()
+
+
+@pytest.mark.parametrize("install_test_plugin", ["test_load_questionnaire"], indirect=True)
+def test_from_yaml_forbidden_questionnaire(
+    install_test_plugin: Path, load_test_plugins: None
+) -> None:
+    """Test that the from_yaml function raises an error for a questionnaire outside plugin package."""
+    plugin = LOADED_PLUGINS[
+        "test_load_questionnaire:test_load_questionnaire.protocols.my_protocol:ForbiddenQuestionnaire"
+    ]
+    with pytest.raises(PermissionError):
+        plugin["class"](Event(EventRequest(type=EventType.UNKNOWN))).compute()
+
+
+def test_from_yaml_non_plugin_caller() -> None:
+    """Test that the from_yaml function returns None when called outside a plugin."""
+    assert questionnaire_from_yaml("questionnaires/example_questionnaire.yml") is None
+
+
+@pytest.mark.parametrize("install_test_plugin", ["test_load_questionnaire"], indirect=True)
+def test_from_yaml_sets_default_values(install_test_plugin: Path) -> None:
+    """Test that the from_yaml function sets default values for properties."""
+    globals()["__is_plugin__"] = True
+    globals()["__name__"] = "test_load_questionnaire"
+
+    definition = questionnaire_from_yaml("questionnaires/example_questionnaire.yml")
+
+    assert definition is not None
+    assert definition["display_results_in_social_history_section"] is False

canvas_sdk/questionnaires/utils.py

@@ -0,0 +1,117 @@
+import functools
+import json
+from collections.abc import Generator
+from pathlib import Path
+from typing import Any, TypedDict
+
+import yaml
+from jsonschema import Draft7Validator, validators
+
+from canvas_sdk.utils.plugins import plugin_only
+
+
+class Response(TypedDict):
+    """A Response of a Questionnaire."""
+
+    name: str
+    code: str
+    code_description: str
+    value: str
+
+
+class Question(TypedDict):
+    """A Question of a Questionnaire."""
+
+    code_system: str
+    code: str
+    code_description: str
+    content: str
+    responses_code_system: str
+    responses_type: str
+    display_result_in_social_history_section: bool
+    responses: list[Response]
+
+
+class QuestionnaireConfig(TypedDict):
+    """A Questionnaire configuration."""
+
+    name: str
+    form_type: str
+    code_system: str
+    code: str
+    can_originate_in_charting: bool
+    prologue: str
+    display_results_in_social_history_section: bool
+    questions: list[Question]
+
+
+def extend_with_defaults(validator_class: type[Draft7Validator]) -> type[Draft7Validator]:
+    """Extend a Draft7Validator with default values for properties."""
+    validate_properties = validator_class.VALIDATORS["properties"]
+
+    def set_defaults(
+        validator: Draft7Validator,
+        properties: dict[str, Any],
+        instance: dict[str, Any],
+        schema: dict[str, Any],
+    ) -> Generator[Any, None, None]:
+        for property, subschema in properties.items():
+            if "default" in subschema:
+                instance.setdefault(property, subschema["default"])
+
+        yield from validate_properties(
+            validator,
+            properties,
+            instance,
+            schema,
+        )
+
+    return validators.extend(
+        validator_class,
+        {"properties": set_defaults},
+    )
+
+
+ExtendedDraft7Validator = extend_with_defaults(Draft7Validator)
+
+
+@plugin_only
+def from_yaml(questionnaire_name: str, **kwargs: Any) -> QuestionnaireConfig | None:
+    """Load a Questionnaire configuration from a YAML file.
+
+    Args:
+        questionnaire_name (str): The path to the questionnaire file, relative to the plugin package.
+            If the path starts with a forward slash ("/"), it will be stripped during resolution.
+        kwargs (Any): Additional keyword arguments.
+
+    Returns:
+        QuestionnaireConfig: The loaded Questionnaire configuration.
+
+    Raises:
+        FileNotFoundError: If the questionnaire file does not exist within the plugin's directory
+            or if the resolved path is invalid.
+        PermissionError: If the resolved path is outside the plugin's directory.
+        ValidationError: If the questionnaire file does not conform to the JSON schema.
+    """
+    plugin_dir = kwargs["plugin_dir"]
+    questionnaire_config_path = Path(plugin_dir / questionnaire_name.lstrip("/")).resolve()
+
+    if not questionnaire_config_path.is_relative_to(plugin_dir):
+        raise PermissionError(f"Invalid Questionnaire '{questionnaire_name}'")
+    elif not questionnaire_config_path.exists():
+        raise FileNotFoundError(f"Questionnaire {questionnaire_name} not found.")
+
+    questionnaire_config = yaml.load(questionnaire_config_path.read_text(), Loader=yaml.SafeLoader)
+    ExtendedDraft7Validator(json_schema()).validate(questionnaire_config)
+
+    return questionnaire_config
+
+
+@functools.cache
+def json_schema() -> dict[str, Any]:
+    """Reads the JSON schema for a Questionnaire Config."""
+    schema = json.loads(
+        (Path(__file__).resolve().parent.parent.parent / "schemas/questionnaire.json").read_text()
+    )
+
+    return schema

canvas_sdk/templates/utils.py

@@ -1,13 +1,15 @@
-import inspect
 from pathlib import Path
 from typing import Any
 
 from django.template import Context, Template
 
-from settings import PLUGIN_DIRECTORY
+from canvas_sdk.utils.plugins import plugin_only
 
 
-def render_to_string(template_name: str, context: dict[str, Any] | None = None) -> str | None:
+@plugin_only
+def render_to_string(
+    template_name: str, context: dict[str, Any] | None = None, **kwargs: Any
+) -> str | None:
     """Load a template and render it with the given context.
 
     Args:
@@ -15,6 +17,7 @@ def render_to_string(template_name: str, context: dict[str, Any] | None = None)
             If the path starts with a forward slash ("/"), it will be stripped during resolution.
         context (dict[str, Any] | None): A dictionary of variables to pass to the template
             for rendering. Defaults to None, which uses an empty context.
+        kwargs (Any): Additional keyword arguments.
 
     Returns:
         str: The rendered template as a string.
@@ -23,15 +26,7 @@ def render_to_string(template_name: str, context: dict[str, Any] | None = None)
         FileNotFoundError: If the template file does not exist within the plugin's directory
             or if the resolved path is invalid.
     """
-    plugins_dir = Path(PLUGIN_DIRECTORY).resolve()
-    current_frame = inspect.currentframe()
-    caller = current_frame.f_back if current_frame else None
-
-    if not caller or "__is_plugin__" not in caller.f_globals:
-        return None
-
-    plugin_name = caller.f_globals["__name__"].split(".")[0]
-    plugin_dir = plugins_dir / plugin_name
+    plugin_dir = kwargs["plugin_dir"]
     template_path = Path(plugin_dir / template_name.lstrip("/")).resolve()
 
     if not template_path.is_relative_to(plugin_dir):

canvas_sdk/utils/__init__.py

@@ -1,3 +1,9 @@
-from canvas_sdk.utils.http import Http
+from canvas_sdk.utils.http import Http, batch_get, batch_patch, batch_post, batch_put
 
-__all__ = ("Http",)
+__all__ = (
+    "Http",
+    "batch_get",
+    "batch_patch",
+    "batch_post",
+    "batch_put",
+)

canvas_sdk/utils/http.py

@@ -1,7 +1,10 @@
+import concurrent
+import functools
 import time
-from collections.abc import Callable, Mapping
+from collections.abc import Callable, Iterable, Mapping
+from concurrent.futures import ThreadPoolExecutor
 from functools import wraps
-from typing import Any, TypeVar, cast
+from typing import Any, Literal, Protocol, TypeVar, cast
 
 import requests
 import statsd
@@ -9,9 +12,90 @@ import statsd
 F = TypeVar("F", bound=Callable)
 
 
+class _BatchableRequest:
+    """Representation of a request that will be executed in parallel with other requests."""
+
+    def __init__(
+        self, method: Literal["GET", "POST", "PUT", "PATCH"], url: str, **kwargs: Any
+    ) -> None:
+        self._method = method
+        self._url = url
+        self._kwargs = kwargs
+
+    def fn(self, client: "Http") -> Callable:
+        """
+        Return a callable constructed from an Http object and the method, URL, and kwargs.
+
+        The callable is passed to the ThreadPoolExecutor.
+        """
+        client_method: Callable
+        match self._method:
+            case "GET":
+                client_method = client.get
+            case "POST":
+                client_method = client.post
+            case "PUT":
+                client_method = client.put
+            case "PATCH":
+                client_method = client.patch
+            case _:
+                raise ValueError(f"HTTP method {self._method} is not supported")
+
+        return functools.partial(client_method, self._url, **self._kwargs)
+
+
+class BatchableRequest(Protocol):
+    """Protocol for batchable requests."""
+
+    def fn(self, client: "Http") -> Callable:
+        """
+        Return a callable that can be passed to the ThreadPoolExecutor.
+        """
+        ...
+
+
+def batch_get(
+    url: str, headers: Mapping[str, str | bytes | None] | None = None
+) -> BatchableRequest:
+    """Return a batchable GET request."""
+    return _BatchableRequest("GET", url, headers=headers)
+
+
+def batch_post(
+    url: str,
+    json: dict | None = None,
+    data: dict | str | list | bytes | None = None,
+    headers: Mapping[str, str | bytes | None] | None = None,
+) -> BatchableRequest:
+    """Return a batchable POST request."""
+    return _BatchableRequest("POST", url, json=json, data=data, headeres=headers)
+
+
+def batch_put(
+    url: str,
+    json: dict | None = None,
+    data: dict | str | list | bytes | None = None,
+    headers: Mapping[str, str | bytes | None] | None = None,
+) -> BatchableRequest:
+    """Return a batchable PUT request."""
+    return _BatchableRequest("PUT", url, json=json, data=data, headers=headers)
+
+
+def batch_patch(
+    url: str,
+    json: dict | None = None,
+    data: dict | str | list | bytes | None = None,
+    headers: Mapping[str, str | bytes | None] | None = None,
+) -> BatchableRequest:
+    """Return a batchable PATCH request."""
+    return _BatchableRequest("PATCH", url, json=json, data=data, headers=headers)
+
+
 class Http:
     """A helper class for completing HTTP calls with metrics tracking."""
 
+    _MAX_WORKER_TIMEOUT_SECONDS = 30
+
     def __init__(self) -> None:
         self.session = requests.Session()
         self.statsd_client = statsd.StatsClient()
@@ -72,3 +156,29 @@ class Http:
     ) -> requests.Response:
         """Sends a PATCH request."""
         return self.session.patch(url, json=json, data=data, headers=headers)
+
+    @measure_time
+    def batch_requests(
+        self,
+        batch_requests: Iterable[BatchableRequest],
+        timeout: int | None = None,
+    ) -> list[requests.Response]:
+        """
+        Execute requests in parallel.
+
+        Wait for the responses to complete, and then return a list of the responses in the same
+        ordering as the requests.
+        """
+        if timeout is None:
+            timeout = self._MAX_WORKER_TIMEOUT_SECONDS
+        elif timeout < 1 or timeout > self._MAX_WORKER_TIMEOUT_SECONDS:
+            raise ValueError(
+                f"Timeout value must be greater than 0 and less than or equal to {self._MAX_WORKER_TIMEOUT_SECONDS} seconds"
+            )
+
+        with ThreadPoolExecutor() as executor:
+            futures = [executor.submit(request.fn(self)) for request in batch_requests]
+
+            concurrent.futures.wait(futures, timeout=timeout)
+
+            return [future.result() for future in futures]

canvas_sdk/utils/plugins.py

@@ -0,0 +1,25 @@
+import inspect
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any
+
+from settings import PLUGIN_DIRECTORY
+
+
+def plugin_only(func: Callable[..., Any]) -> Callable[..., Any]:
+    """Decorator to restrict a function's execution to plugins only."""
+
+    def wrapper(*args: Any, **kwargs: Any) -> Any:
+        current_frame = inspect.currentframe()
+        caller = current_frame.f_back if current_frame else None
+
+        if not caller or "__is_plugin__" not in caller.f_globals:
+            return None
+
+        plugin_name = caller.f_globals["__name__"].split(".")[0]
+        plugin_dir = Path(PLUGIN_DIRECTORY) / plugin_name
+        kwargs["plugin_dir"] = plugin_dir.resolve()
+
+        return func(*args, **kwargs)
+
+    return wrapper

canvas_sdk/v1/data/__init__.py

@@ -1,7 +1,7 @@
 from .allergy_intolerance import AllergyIntolerance, AllergyIntoleranceCoding
 from .appointment import Appointment
 from .assessment import Assessment
-from .billing import BillingLineItem
+from .billing import BillingLineItem, BillingLineItemModifier
 from .care_team import CareTeamMembership, CareTeamRole
 from .command import Command
 from .condition import Condition, ConditionCoding
@@ -48,6 +48,7 @@ from .questionnaire import (
     ResponseOption,
     ResponseOptionSet,
 )
+from .reason_for_visit import ReasonForVisitSettingCoding
 from .staff import Staff
 from .task import Task, TaskComment, TaskLabel, TaskTaskLabel
 from .user import CanvasUser
@@ -58,6 +59,7 @@ __all__ = [
     "AllergyIntoleranceCoding",
     "Assessment",
     "BillingLineItem",
+    "BillingLineItemModifier",
     "CanvasUser",
     "CareTeamMembership",
     "CareTeamRole",
@@ -103,6 +105,7 @@ __all__ = [
     "Question",
     "Questionnaire",
     "QuestionnaireQuestionMap",
+    "ReasonForVisitSettingCoding",
     "ResponseOption",
     "ResponseOptionSet",
     "Staff",