canvas 0.53.2__py3-none-any.whl → 0.55.0__py3-none-any.whl

canvas_generated/messages/events_pb2.pyi

@@ -856,6 +856,7 @@ class EventType(int, metaclass=_enum_type_wrapper.EnumTypeWrapper):
     PATIENT_CHART_SUMMARY__SECTION_CONFIGURATION: _ClassVar[EventType]
     PATIENT_PROFILE__SECTION_CONFIGURATION: _ClassVar[EventType]
     PATIENT_PROFILE__ADD_PHARMACY__POST_SEARCH: _ClassVar[EventType]
+    PATIENT_CHART__MEDICATIONS: _ClassVar[EventType]
     CLAIM__CONDITIONS: _ClassVar[EventType]
     PLUGIN_CREATED: _ClassVar[EventType]
     PLUGIN_UPDATED: _ClassVar[EventType]
@@ -899,6 +900,13 @@ class EventType(int, metaclass=_enum_type_wrapper.EnumTypeWrapper):
     DOCUMENT_REFERENCE_CREATED: _ClassVar[EventType]
     DOCUMENT_REFERENCE_UPDATED: _ClassVar[EventType]
     DOCUMENT_REFERENCE_DELETED: _ClassVar[EventType]
+    PANEL_SECTIONS_CONFIGURATION: _ClassVar[EventType]
+    REVENUE__PAYMENT_PROCESSOR__LIST: _ClassVar[EventType]
+    REVENUE__PAYMENT_PROCESSOR__CHARGE: _ClassVar[EventType]
+    REVENUE__PAYMENT_PROCESSOR__SELECTED: _ClassVar[EventType]
+    REVENUE__PAYMENT_PROCESSOR__PAYMENT_METHODS__LIST: _ClassVar[EventType]
+    REVENUE__PAYMENT_PROCESSOR__PAYMENT_METHODS__ADD: _ClassVar[EventType]
+    REVENUE__PAYMENT_PROCESSOR__PAYMENT_METHODS__REMOVE: _ClassVar[EventType]
 UNKNOWN: EventType
 ALLERGY_INTOLERANCE_CREATED: EventType
 ALLERGY_INTOLERANCE_UPDATED: EventType
@@ -1746,6 +1754,7 @@ PATIENT_CHART__CONDITIONS: EventType
 PATIENT_CHART_SUMMARY__SECTION_CONFIGURATION: EventType
 PATIENT_PROFILE__SECTION_CONFIGURATION: EventType
 PATIENT_PROFILE__ADD_PHARMACY__POST_SEARCH: EventType
+PATIENT_CHART__MEDICATIONS: EventType
 CLAIM__CONDITIONS: EventType
 PLUGIN_CREATED: EventType
 PLUGIN_UPDATED: EventType
@@ -1789,6 +1798,13 @@ PATIENT_METADATA_UPDATED: EventType
 DOCUMENT_REFERENCE_CREATED: EventType
 DOCUMENT_REFERENCE_UPDATED: EventType
 DOCUMENT_REFERENCE_DELETED: EventType
+PANEL_SECTIONS_CONFIGURATION: EventType
+REVENUE__PAYMENT_PROCESSOR__LIST: EventType
+REVENUE__PAYMENT_PROCESSOR__CHARGE: EventType
+REVENUE__PAYMENT_PROCESSOR__SELECTED: EventType
+REVENUE__PAYMENT_PROCESSOR__PAYMENT_METHODS__LIST: EventType
+REVENUE__PAYMENT_PROCESSOR__PAYMENT_METHODS__ADD: EventType
+REVENUE__PAYMENT_PROCESSOR__PAYMENT_METHODS__REMOVE: EventType
 
 class Event(_message.Message):
     __slots__ = ("type", "target", "context", "target_type")

canvas_sdk/caching/client.py

@@ -8,7 +8,9 @@ caches: dict[tuple[str, str], Cache] = {}
 
 
 def get_cache(
-    driver: str = "default", prefix: str = "", max_timeout_seconds: int | None = None
+    driver: str = "default",
+    prefix: str = "",
+    max_timeout_seconds: int | None = None,
 ) -> Cache:
     """Get the cache client based on the specified driver."""
     try:

canvas_sdk/caching/plugins.py

@@ -3,18 +3,21 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Any
 
 from canvas_sdk.caching.client import get_cache as get_cache_client
-from canvas_sdk.utils.plugins import plugin_only
+from canvas_sdk.utils.plugins import plugin_context
 from settings import CANVAS_SDK_CACHE_TIMEOUT_SECONDS
 
 if TYPE_CHECKING:
     from canvas_sdk.caching.base import Cache
 
 
-@plugin_only
+@plugin_context
 def get_cache(**kwargs: Any) -> Cache:
     """Get the cache client for plugins."""
-    prefix = kwargs["plugin_name"]
-    return get_cache_client("plugins", prefix, CANVAS_SDK_CACHE_TIMEOUT_SECONDS)
+    return get_cache_client(
+        driver="plugins",
+        prefix=kwargs["plugin_name"],
+        max_timeout_seconds=CANVAS_SDK_CACHE_TIMEOUT_SECONDS,
+    )
 
 
 __exports__ = ("get_cache",)

canvas_sdk/effects/group.py

@@ -0,0 +1,20 @@
+from typing import Any
+
+from canvas_sdk.base import Model
+
+
+class Group(Model):
+    """
+    Class representing a group of items.
+    """
+
+    items: list[Any]
+    priority: int
+    name: str
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert the Group object to a dictionary."""
+        return {"items": self.items, "priority": self.priority, "name": self.name}
+
+
+__exports__ = ("Group",)

canvas_sdk/effects/panel_configuration.py

@@ -0,0 +1,90 @@
+from enum import Enum
+from typing import Any
+
+from pydantic import Field
+from pydantic_core import InitErrorDetails
+
+from canvas_sdk.effects.base import EffectType, _BaseEffect
+
+
+class PanelConfiguration(_BaseEffect):
+    """
+    An Effect that will decide which buttons appear on the panel section in Canvas.
+    """
+
+    class Meta:
+        effect_type = EffectType.SHOW_PANEL_SECTIONS
+
+    class Page(Enum):
+        GLOBAL = "global"
+        PATIENT = "patient"
+
+    class PanelGlobalSection(Enum):
+        APPOINTMENT = "appointment"
+        CHANGE_REQUEST = "changeRequest"
+        IMAGING_REPORT = "imagingReport"
+        INPATIENT_STAY = "inpatientStay"
+        LAB_REPORT = "labReport"
+        MESSAGE = "message"
+        OUTSTANDING_REFERRAL = "outstandingReferral"
+        PRESCRIPTION_ALERT = "prescriptionAlert"
+        RECALL_APPOINTMENT = "recallAppointment"
+        REFERRAL_REPORT = "referralReport"
+        REFILL_REQUEST = "refillRequest"
+        TASK = "task"
+        UNCATEGORIZED_DOCUMENT = "uncategorizedDocument"
+
+    class PanelPatientSection(Enum):
+        CHANGE_REQUEST = "changeRequest"
+        COMMAND = "command"
+        IMAGING_REPORT = "imagingReport"
+        INPATIENT_STAY = "inpatientStay"
+        LAB_REPORT = "labReport"
+        PRESCRIPTION_ALERT = "prescriptionAlert"
+        REFERRAL_REPORT = "referralReport"
+        REFILL_REQUEST = "refillRequest"
+        TASK = "task"
+        UNCATEGORIZED_DOCUMENT = "uncategorizedDocument"
+
+    sections: list[PanelPatientSection] | list[PanelGlobalSection] = Field(min_length=1)
+    page: Page
+
+    @property
+    def values(self) -> dict[str, Any]:
+        """The PanelConfiguration'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}
+
+    def _get_error_details(self, method: Any) -> list[InitErrorDetails]:
+        errors = super()._get_error_details(method)
+
+        if self.page == PanelConfiguration.Page.GLOBAL and not all(
+            isinstance(s, PanelConfiguration.PanelGlobalSection) for s in self.sections
+        ):
+            errors.append(
+                self._create_error_detail(
+                    "value",
+                    "All sections must be of type PanelGlobalSection",
+                    self.sections,
+                )
+            )
+
+        if self.page == PanelConfiguration.Page.PATIENT and not all(
+            isinstance(s, PanelConfiguration.PanelPatientSection) for s in self.sections
+        ):
+            errors.append(
+                self._create_error_detail(
+                    "value",
+                    "All sections must be of type PanelPatientSection",
+                    self.sections,
+                )
+            )
+
+        return errors
+
+
+__exports__ = ("PanelConfiguration",)

canvas_sdk/effects/patient_chart_group.py

@@ -0,0 +1,30 @@
+from typing import Any
+
+from canvas_sdk.effects.base import EffectType, _BaseEffect
+from canvas_sdk.effects.group import Group
+
+
+class PatientChartGroup(_BaseEffect):
+    """
+    An Effect that groups chart items by name and priority.
+    """
+
+    class Meta:
+        effect_type = EffectType.PATIENT_CHART__GROUP_ITEMS
+
+    items: dict[str, Group]
+
+    @property
+    def values(self) -> dict[str, Any]:
+        """The chart items."""
+        return {
+            "items": [item.to_dict() for item in self.items.values() if isinstance(item, Group)]
+        }
+
+    @property
+    def effect_payload(self) -> dict[str, Any]:
+        """The payload of the effect."""
+        return {"data": self.values}
+
+
+__exports__ = ("PatientChartGroup",)

canvas_sdk/effects/payment_processor.py

@@ -0,0 +1,137 @@
+from enum import StrEnum
+from typing import Any
+
+from canvas_sdk.effects import EffectType, _BaseEffect
+
+
+class PaymentProcessorMetadata(_BaseEffect):
+    """PaymentProcessorInfo effect class."""
+
+    class Meta:
+        effect_type = EffectType.REVENUE__PAYMENT_PROCESSOR__METADATA
+
+    class PaymentProcessorType(StrEnum):
+        """Enum for payment processor types."""
+
+        CARD = "card"
+
+    identifier: str
+    type: PaymentProcessorType
+
+    @property
+    def values(self) -> dict[str, Any]:
+        """Return the values of the PaymentProcessorMetadata."""
+        return {
+            "identifier": self.identifier,
+            "type": self.type.value,
+        }
+
+
+class PaymentProcessorForm(_BaseEffect):
+    """PaymentProcessorForm effect class."""
+
+    class Meta:
+        effect_type = EffectType.REVENUE__PAYMENT_PROCESSOR__FORM
+
+    intent: str
+    content: str
+
+    @property
+    def values(self) -> dict[str, Any]:
+        """Return the values of the PaymentProcessorMetadata."""
+        return {
+            "intent": self.intent,
+            "content": self.content,
+        }
+
+
+class CardTransaction(_BaseEffect):
+    """CardTransaction effect class."""
+
+    class Meta:
+        effect_type = EffectType.REVENUE__PAYMENT_PROCESSOR__CREDIT_CARD_TRANSACTION
+
+    success: bool
+    transaction_id: str | None
+    error_code: str | None = None
+    api_response: dict
+
+    @property
+    def values(self) -> dict[str, Any]:
+        """Return the values of the CreditCardTransaction."""
+        return {
+            "success": self.success,
+            "transaction_id": self.transaction_id,
+            "api_response": self.api_response,
+            "error_code": self.error_code,
+        }
+
+
+class PaymentMethod(_BaseEffect):
+    """PaymentMethod effect class."""
+
+    class Meta:
+        effect_type = EffectType.REVENUE__PAYMENT_PROCESSOR__PAYMENT_METHOD
+
+    payment_method_id: str
+    card_holder_name: str | None
+    brand: str
+    postal_code: str | None = None
+    country: str | None = None
+    expiration_year: int
+    expiration_month: int
+    card_last_four_digits: str
+
+    @property
+    def values(self) -> dict[str, Any]:
+        """Return the values of the PaymentMethod."""
+        return {
+            "payment_method_id": self.payment_method_id,
+            "card_holder_name": self.card_holder_name,
+            "brand": self.brand,
+            "postal_code": self.postal_code,
+            "country": self.country,
+            "expiration_year": self.expiration_year,
+            "expiration_month": self.expiration_month,
+            "card_last_four_digits": self.card_last_four_digits,
+        }
+
+
+class AddPaymentMethodResponse(_BaseEffect):
+    """AddPaymentMethodResponse effect class."""
+
+    class Meta:
+        effect_type = EffectType.REVENUE__PAYMENT_PROCESSOR__PAYMENT_METHOD__ADD_RESPONSE
+
+    success: bool
+
+    @property
+    def values(self) -> dict[str, Any]:
+        """Return the values of the AddPaymentMethodResponse."""
+        return {"success": self.success}
+
+
+class RemovePaymentMethodResponse(_BaseEffect):
+    """RemovePaymentMethodResponse effect class."""
+
+    class Meta:
+        effect_type = EffectType.REVENUE__PAYMENT_PROCESSOR__PAYMENT_METHOD__REMOVE_RESPONSE
+
+    success: bool
+
+    @property
+    def values(self) -> dict[str, Any]:
+        """Return the values of the RemovePaymentMethodResponse."""
+        return {
+            "success": self.success,
+        }
+
+
+__exports__ = (
+    "PaymentProcessorMetadata",
+    "PaymentProcessorForm",
+    "CardTransaction",
+    "PaymentMethod",
+    "AddPaymentMethodResponse",
+    "RemovePaymentMethodResponse",
+)

canvas_sdk/handlers/payment_processors/__init__.py

@@ -0,0 +1 @@
+__exports__ = ()

canvas_sdk/handlers/payment_processors/base.py

@@ -0,0 +1,93 @@
+import base64
+from abc import ABC
+
+from canvas_sdk.effects import Effect
+from canvas_sdk.effects.payment_processor import PaymentProcessorMetadata
+from canvas_sdk.events import EventType
+from canvas_sdk.handlers import BaseHandler
+
+
+class PaymentProcessor(BaseHandler, ABC):
+    """
+    Abstract Base class for payment processors.
+    """
+
+    RESPONDS_TO = [
+        EventType.Name(EventType.REVENUE__PAYMENT_PROCESSOR__LIST),
+        EventType.Name(EventType.REVENUE__PAYMENT_PROCESSOR__SELECTED),
+        EventType.Name(EventType.REVENUE__PAYMENT_PROCESSOR__CHARGE),
+        EventType.Name(EventType.REVENUE__PAYMENT_PROCESSOR__PAYMENT_METHODS__LIST),
+        EventType.Name(EventType.REVENUE__PAYMENT_PROCESSOR__PAYMENT_METHODS__ADD),
+        EventType.Name(EventType.REVENUE__PAYMENT_PROCESSOR__PAYMENT_METHODS__REMOVE),
+    ]
+
+    TYPE: PaymentProcessorMetadata.PaymentProcessorType
+
+    @property
+    def identifier(self) -> str:
+        """The application identifier."""
+        identifier = f"{self.__class__.__module__}:{self.__class__.__qualname__}"
+
+        return base64.b64encode(identifier.encode("utf-8")).decode("utf-8")
+
+    def compute(self) -> list[Effect]:
+        """Compute the effects to be applied."""
+        if self.event.type == EventType.REVENUE__PAYMENT_PROCESSOR__LIST and (
+            "payment_type" not in self.event.context
+            or self.event.context["payment_type"] == self.TYPE
+        ):
+            return [self.metadata().apply()]
+        elif self.event.type == EventType.REVENUE__PAYMENT_PROCESSOR__SELECTED:
+            effects = self._on_payment_processor_selected()
+            return effects
+        elif self.event.type == EventType.REVENUE__PAYMENT_PROCESSOR__CHARGE:
+            effect = self._charge()
+            return [effect] if effect else []
+        elif self.event.type == EventType.REVENUE__PAYMENT_PROCESSOR__PAYMENT_METHODS__LIST:
+            # This event is used to list payment methods, which may not be applicable for all processors.
+            # Subclasses should override this method if they support listing payment methods.
+            return self._payment_methods()
+        elif self.event.type == EventType.REVENUE__PAYMENT_PROCESSOR__PAYMENT_METHODS__ADD:
+            effect = self._add_payment_method()
+            return [effect] if effect else []
+        elif self.event.type == EventType.REVENUE__PAYMENT_PROCESSOR__PAYMENT_METHODS__REMOVE:
+            effect = self._remove_payment_method()
+            return [effect] if effect else []
+
+        return []
+
+    def metadata(self) -> PaymentProcessorMetadata:
+        """Return information about the payment processor."""
+        return PaymentProcessorMetadata(identifier=self.identifier, type=self.TYPE)
+
+    def _on_payment_processor_selected(self) -> list[Effect]:
+        """Handle the event when a payment processor is selected."""
+        # This method should be overridden by subclasses to handle specific logic
+        # when a payment processor is selected.
+        return []
+
+    def _charge(self) -> Effect | None:
+        """Handle the event when a charge is made."""
+        # This method should be overridden by subclasses to handle specific logic
+        # when a charge is made.
+        return None
+
+    def _payment_methods(self) -> list[Effect]:
+        """List payment methods for the processor."""
+        # This method should be overridden by subclasses if they support listing payment methods.
+        return []
+
+    def _add_payment_method(self) -> Effect | None:
+        """Handle the event when a payment method is added."""
+        # This method should be overridden by subclasses to handle specific logic
+        # when a payment method is added.
+        return None
+
+    def _remove_payment_method(self) -> Effect | None:
+        """Handle the event when a payment method is removed."""
+        # This method should be overridden by subclasses to handle specific logic
+        # when a payment method is removed.
+        return None
+
+
+__exports__ = ("PaymentProcessor",)

canvas_sdk/handlers/payment_processors/card.py

@@ -0,0 +1,200 @@
+from abc import ABC, abstractmethod
+from decimal import Decimal
+from enum import StrEnum
+
+from canvas_sdk.effects import Effect
+from canvas_sdk.effects.payment_processor import (
+    AddPaymentMethodResponse,
+    CardTransaction,
+    PaymentMethod,
+    PaymentProcessorForm,
+    PaymentProcessorMetadata,
+    RemovePaymentMethodResponse,
+)
+from canvas_sdk.handlers.payment_processors.base import PaymentProcessor
+from canvas_sdk.v1.data import Patient
+
+
+class CardPaymentProcessor(PaymentProcessor, ABC):
+    """Base Card Payment Processor Handler."""
+
+    TYPE = PaymentProcessorMetadata.PaymentProcessorType.CARD
+
+    class PaymentIntent(StrEnum):
+        """Enum for payment actions."""
+
+        ADD_CARD = "add_card"
+        PAY = "pay"
+
+    def _on_payment_processor_selected(self) -> list[Effect]:
+        """Handle the event when a payment processor is selected."""
+        if self.event.context.get("identifier") == self.identifier:
+            intent = self.event.context.get("intent")
+            effects = self.on_payment_processor_selected(intent=intent)
+            return [effect.apply() for effect in effects]
+
+        return []
+
+    def _charge(self) -> Effect | None:
+        """Handle the event when a charge is made."""
+        if self.event.context.get("identifier") == self.identifier:
+            patient = (
+                Patient.objects.get(id=self.event.context.get("patient", {}).get("id"))
+                if self.event.context.get("patient")
+                else None
+            )
+
+            amount = Decimal(str(self.event.context.get("amount")))
+            token = str(self.event.context.get("token"))
+            effect = self.charge(amount=amount, token=token, patient=patient)
+
+            return effect.apply() if effect else None
+
+        return None
+
+    def _payment_methods(self) -> list[Effect]:
+        """List payment methods for the card payment processor."""
+        if self.event.context.get("identifier") == self.identifier:
+            patient = (
+                Patient.objects.get(id=self.event.context.get("patient", {}).get("id"))
+                if self.event.context.get("patient")
+                else None
+            )
+            effects = self.payment_methods(patient=patient)
+            return [effect.apply() for effect in effects]
+
+        return []
+
+    def _add_payment_method(self) -> Effect | None:
+        """Handle the event when a card is added."""
+        if self.event.context.get("identifier") == self.identifier:
+            patient = (
+                Patient.objects.get(id=self.event.context.get("patient", {}).get("id"))
+                if self.event.context.get("patient")
+                else None
+            )
+
+            if not patient:
+                return None
+
+            token = str(self.event.context.get("token"))
+            effect = self.add_payment_method(token=token, patient=patient)
+            return effect.apply() if effect else None
+
+        return None
+
+    def _remove_payment_method(self) -> Effect | None:
+        """Handle the event when a payment method is removed."""
+        if self.event.context.get("identifier") == self.identifier:
+            patient = (
+                Patient.objects.get(id=self.event.context.get("patient", {}).get("id"))
+                if self.event.context.get("patient")
+                else None
+            )
+
+            if not patient:
+                return None
+
+            token = str(self.event.context.get("token"))
+            effect = self.remove_payment_method(token=token, patient=patient)
+            return effect.apply() if effect else None
+
+        return None
+
+    def on_payment_processor_selected(self, intent: str | None) -> list[PaymentProcessorForm]:
+        """Handle the event when a payment processor is selected."""
+        patient = (
+            Patient.objects.get(id=self.event.context.get("patient", {}).get("id"))
+            if self.event.context.get("patient")
+            else None
+        )
+        match intent:
+            case self.PaymentIntent.ADD_CARD:
+                return [self.add_card_form(patient)]
+            case self.PaymentIntent.PAY:
+                return [self.payment_form(patient)]
+            case None:
+                return [self.payment_form(patient), self.add_card_form(patient)]
+            case _:
+                return []
+
+    @abstractmethod
+    def payment_form(self, patient: Patient | None = None) -> PaymentProcessorForm:
+        """Return the payment form for the credit card processor.
+
+        Args:
+            patient (Patient | None): The patient for whom the payment is being processed.
+
+        Returns:
+            PaymentProcessorForm: The form for processing the payment.
+        """
+        raise NotImplementedError("Subclasses must implement the payment_form method.")
+
+    @abstractmethod
+    def add_card_form(self, patient: Patient | None = None) -> PaymentProcessorForm:
+        """Return the form for adding a card.
+
+        Args:
+            patient (Patient | None): The patient for whom the add is being added.
+
+        Returns:
+            PaymentProcessorForm: The form for adding a card.
+        """
+        raise NotImplementedError("Subclasses must implement the add_card_form method.")
+
+    @abstractmethod
+    def charge(
+        self, amount: Decimal, token: str, patient: Patient | None = None
+    ) -> CardTransaction:
+        """Charge a credit/debit card using the provided token.
+
+        Args:
+            amount (Decimal): The amount to charge.
+            token (str): The token representing the credit card.
+            patient (Patient | None): The patient for whom the charge is being made.
+
+        Returns:
+            CardTransaction: The result of the card transaction.
+        """
+        raise NotImplementedError("Subclasses must implement the charge method.")
+
+    @abstractmethod
+    def payment_methods(self, patient: Patient | None = None) -> list[PaymentMethod]:
+        """List payment methods for the card payment processor.
+
+        Args:
+            patient (Patient | None): The patient for whom the payment methods are being listed.
+
+        Returns:
+            list[PaymentMethod]: A list of payment methods available for the card payment processor.
+        """
+        raise NotImplementedError("Subclasses must implement the payment_methods method.")
+
+    @abstractmethod
+    def add_payment_method(self, token: str, patient: Patient) -> AddPaymentMethodResponse:
+        """Add a payment method for the card payment processor.
+
+        Args:
+            token (str): The token representing the payment method.
+            patient (Patient): The patient for whom the payment method is being added.
+
+        Returns:
+            AddPaymentMethodResponse: The response indicating the result of the addition operation.
+        """
+        raise NotImplementedError("Subclasses must implement the add_payment_method method.")
+
+    @abstractmethod
+    def remove_payment_method(self, token: str, patient: Patient) -> RemovePaymentMethodResponse:
+        """Remove a payment method for the card payment processor.
+
+        Args:
+            token (str): The token representing the payment method to be removed.
+            patient (Patient): The patient for whom the payment method is being removed.
+
+        Returns:
+            RemovePaymentMethodResponse: The response indicating the result of the removal operation.
+        """
+        raise NotImplementedError("Subclasses must implement the remove_payment_method method.")
+
+
+__exports__ = ("CardPaymentProcessor",)

canvas_sdk/questionnaires/utils.py

@@ -7,7 +7,7 @@ from typing import Any, TypedDict
 import yaml
 from jsonschema import Draft7Validator, validators
 
-from canvas_sdk.utils.plugins import plugin_only
+from canvas_sdk.utils.plugins import plugin_context
 
 
 class Response(TypedDict):
@@ -75,7 +75,7 @@ def extend_with_defaults(validator_class: type[Draft7Validator]) -> type[Draft7V
 ExtendedDraft7Validator = extend_with_defaults(Draft7Validator)
 
 
-@plugin_only
+@plugin_context
 def from_yaml(questionnaire_name: str, **kwargs: Any) -> QuestionnaireConfig | None:
     """Load a Questionnaire configuration from a YAML file.