canvas 0.18.0__tar.gz → 0.19.0__tar.gz

{canvas-0.18.0 → canvas-0.19.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: canvas
-Version: 0.18.0
+Version: 0.19.0
 Summary: SDK to customize event-driven actions in your Canvas instance
 Author-email: Canvas Team <engineering@canvasmedical.com>
 License-Expression: MIT

{canvas-0.18.0 → canvas-0.19.0}/canvas_cli/utils/validators/manifest_schema.py

@@ -16,6 +16,7 @@ manifest_schema = {
                 "effects": {"$ref": "#/$defs/component"},
                 "views": {"$ref": "#/$defs/component"},
                 "applications": {"$ref": "#/$defs/applications"},
+                "questionnaires": {"$ref": "#/$defs/questionnaires"},
             },
             "additionalProperties": False,
             "minProperties": 1,
@@ -101,5 +102,16 @@ manifest_schema = {
                 "additionalProperties": False,
             },
         },
+        "questionnaires": {
+            "type": "array",
+            "items": {
+                "type": "object",
+                "properties": {
+                    "template": {"type": "string"},
+                },
+                "required": ["template"],
+                "additionalProperties": False,
+            },
+        },
     },
 }

{canvas-0.18.0 → canvas-0.19.0}/canvas_sdk/commands/commands/reason_for_visit.py

@@ -1,9 +1,11 @@
 from typing import Literal
+from uuid import UUID
 
 from pydantic_core import InitErrorDetails
 
 from canvas_sdk.commands.base import _BaseCommand
 from canvas_sdk.commands.constants import Coding
+from canvas_sdk.v1.data import ReasonForVisitSettingCoding
 
 
 class ReasonForVisitCommand(_BaseCommand):
@@ -13,8 +15,7 @@ class ReasonForVisitCommand(_BaseCommand):
         key = "reasonForVisit"
 
     structured: bool = False
-    # how do we make sure that coding is a valid rfv coding from their home-app?
-    coding: Coding | None = None
+    coding: Coding | UUID | str | None = None
     comment: str | None = None
 
     def _get_error_details(
@@ -27,6 +28,16 @@ class ReasonForVisitCommand(_BaseCommand):
                     "value", "Structured RFV should have a coding.", self.coding
                 )
             )
+
+        if self.coding:
+            if isinstance(self.coding, str | UUID):
+                query = {"id": self.coding}
+                error_message = f"ReasonForVisitSettingCoding with id {self.coding} does not exist."
+            else:
+                query = {"code": self.coding["code"], "system": self.coding["system"]}
+                error_message = f"ReasonForVisitSettingCoding with code {self.coding['code']} and system {self.coding['system']} does not exist."
+            if not ReasonForVisitSettingCoding.objects.filter(**query).exists():
+                errors.append(self._create_error_detail("value", error_message, self.coding))
         return errors
 
     @classmethod
@@ -40,4 +51,8 @@ class ReasonForVisitCommand(_BaseCommand):
     @property
     def values(self) -> dict:
         """The ReasonForVisit command's field values."""
-        return {"structured": self.structured, "coding": self.coding, "comment": self.comment}
+        return {
+            "structured": self.structured,
+            "coding": str(self.coding) if isinstance(self.coding, UUID) else self.coding,
+            "comment": self.comment,
+        }

{canvas-0.18.0 → canvas-0.19.0}/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-0.18.0 → canvas-0.19.0}/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-0.19.0/canvas_sdk/questionnaires/__init__.py

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

canvas-0.19.0/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-0.19.0/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-0.18.0 → canvas-0.19.0}/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-0.19.0/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-0.18.0 → canvas-0.19.0}/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",

{canvas-0.18.0 → canvas-0.19.0}/canvas_sdk/v1/data/billing.py

@@ -44,10 +44,16 @@ class BillingLineItem(models.Model):
     created = models.DateTimeField()
     modified = models.DateTimeField()
     note = models.ForeignKey(
-        "v1.Note", on_delete=models.DO_NOTHING, related_name="billing_line_items", null=True
+        "v1.Note",
+        on_delete=models.DO_NOTHING,
+        related_name="billing_line_items",
+        null=True,
     )
     patient = models.ForeignKey(
-        "v1.Patient", on_delete=models.DO_NOTHING, related_name="billing_line_items", null=True
+        "v1.Patient",
+        on_delete=models.DO_NOTHING,
+        related_name="billing_line_items",
+        null=True,
     )
     cpt = models.CharField()
     charge = models.DecimalField()
@@ -56,3 +62,24 @@ class BillingLineItem(models.Model):
     command_type = models.CharField()
     command_id = models.IntegerField()
     status = models.CharField(choices=BillingLineItemStatus.choices)
+
+
+class BillingLineItemModifier(models.Model):
+    """BillingLineItemModifier."""
+
+    class Meta:
+        managed = False
+        db_table = "canvas_sdk_data_api_billinglineitemmodifier_001"
+
+    dbid = models.BigIntegerField(primary_key=True)
+    system = models.CharField()
+    version = models.CharField()
+    code = models.CharField()
+    display = models.CharField()
+    user_selected = models.BooleanField()
+    line_item = models.ForeignKey(
+        "v1.BillingLineItem",
+        on_delete=models.DO_NOTHING,
+        related_name="modifiers",
+        null=True,
+    )

{canvas-0.18.0 → canvas-0.19.0}/canvas_sdk/v1/data/coverage.py

@@ -46,7 +46,7 @@ class CoverageRelationshipCode(models.TextChoices):
     """CoverageRelationshipCode."""
 
     SELF = "18", "Self"
-    SPOUSE = "01" "Spouse"
+    SPOUSE = "01", "Spouse"
     CHILD_INSURED_HAS_FINANCIAL_RESP = "19", "Natural Child, insured has financial responsibility"
     CHILD_HAS_FINANCIAL_RESP = "43", "Natural Child, insured does not have financial responsibility"
     STEP_CHILD = "17", "Step Child"

canvas-0.19.0/canvas_sdk/v1/data/reason_for_visit.py

@@ -0,0 +1,22 @@
+from django.contrib.postgres.fields import ArrayField
+from django.db import models
+
+
+class ReasonForVisitSettingCoding(models.Model):
+    """ReasonForVisitSettingCoding."""
+
+    class Meta:
+        managed = False
+        db_table = "canvas_sdk_data_api_reasonforvisitsettingcoding_001"
+
+    objects: models.Manager["ReasonForVisitSettingCoding"]
+
+    id = models.UUIDField()
+    dbid = models.BigIntegerField(primary_key=True)
+
+    code = models.CharField()
+    display = models.CharField()
+    system = models.CharField()
+    version = models.CharField()
+
+    duration = ArrayField(models.DurationField())

{canvas-0.18.0 → canvas-0.19.0}/plugin_runner/sandbox.py

@@ -45,6 +45,7 @@ ALLOWED_MODULES = frozenset(
         "canvas_sdk.events",
         "canvas_sdk.handlers",
         "canvas_sdk.protocols",
+        "canvas_sdk.questionnaires",
         "canvas_sdk.utils",
         "canvas_sdk.templates",
         "canvas_sdk.v1",
@@ -173,12 +174,12 @@ class Sandbox:
             ):
                 self.warn(
                     node,
-                    f'"{name}" is an invalid variable name because it ' 'starts with "_"',
+                    f'"{name}" is an invalid variable name because it starts with "_"',
                 )
             elif name.endswith("__roles__"):
                 self.error(
                     node,
-                    f'"{name}" is an invalid variable name because ' 'it ends with "__roles__".',
+                    f'"{name}" is an invalid variable name because it ends with "__roles__".',
                 )
             elif name in FORBIDDEN_FUNC_NAMES:
                 self.error(node, f'"{name}" is a reserved name.')
@@ -215,21 +216,20 @@ class Sandbox:
             if node.attr.startswith("_") and node.attr != "_":
                 self.warn(
                     node,
-                    f'"{node.attr}" is an invalid attribute name because it starts ' 'with "_".',
+                    f'"{node.attr}" is an invalid attribute name because it starts with "_".',
                 )
 
             if node.attr.endswith("__roles__"):
                 self.error(
                     node,
-                    f'"{node.attr}" is an invalid attribute name because it ends '
-                    'with "__roles__".',
+                    f'"{node.attr}" is an invalid attribute name because it ends with "__roles__".',
                 )
 
             if isinstance(node.ctx, ast.Load):
                 node = self.node_contents_visit(node)
                 new_node = ast.Call(
                     func=ast.Name("_getattr_", ast.Load()),
-                    args=[node.value, ast.Str(node.attr)],
+                    args=[node.value, ast.Constant(node.attr)],
                     keywords=[],
                 )