canvas 0.63.0__py3-none-any.whl → 0.89.0__py3-none-any.whl

canvas_sdk/effects/send_contact_verification.py

@@ -0,0 +1,42 @@
+from typing import Any
+from uuid import UUID
+
+from pydantic_core import InitErrorDetails
+
+from canvas_sdk.effects.base import EffectType, _BaseEffect
+from canvas_sdk.v1.data import PatientContactPoint
+
+
+class SendContactVerificationEffect(_BaseEffect):
+    """
+    An Effect that will send a verification for a Patient Contact Point.
+    """
+
+    class Meta:
+        effect_type = EffectType.PATIENT_PORTAL__SEND_CONTACT_VERIFICATION
+
+    contact_point_id: str | UUID
+
+    @property
+    def values(self) -> dict[str, Any]:
+        """The contact point id."""
+        return {"contact_point_id": self.contact_point_id}
+
+    def _get_error_details(self, method: Any) -> list[InitErrorDetails]:
+        errors = super()._get_error_details(method)
+
+        contact_point_exists = PatientContactPoint.objects.filter(id=self.contact_point_id).exists()
+
+        if not contact_point_exists:
+            errors.append(
+                self._create_error_detail(
+                    "value",
+                    "Patient Contact Point does not exist",
+                    self.contact_point_id,
+                )
+            )
+
+        return errors
+
+
+__exports__ = ("SendContactVerificationEffect",)

canvas_sdk/effects/task/__init__.py

@@ -1,8 +1,9 @@
-from .task import AddTask, AddTaskComment, TaskStatus, UpdateTask
+from .task import AddTask, AddTaskComment, TaskMetadata, TaskStatus, UpdateTask
 
 __all__ = __exports__ = (
     "AddTask",
     "AddTaskComment",
     "TaskStatus",
+    "TaskMetadata",
     "UpdateTask",
 )

canvas_sdk/effects/task/task.py

@@ -4,8 +4,11 @@ from typing import Any, Self, cast
 from uuid import UUID
 
 from pydantic import model_validator
+from pydantic_core import InitErrorDetails
 
 from canvas_sdk.effects.base import EffectType, _BaseEffect
+from canvas_sdk.effects.metadata import BaseMetadata
+from canvas_sdk.v1.data import Task
 
 
 class TaskStatus(Enum):
@@ -140,9 +143,36 @@ class UpdateTask(_BaseEffect):
         return value_dict
 
 
+class TaskMetadata(BaseMetadata):
+    """Task Metadata."""
+
+    class Meta:
+        effect_type = "TASK_METADATA"
+
+    task_id: str
+
+    def _get_error_details(self, method: Any) -> list[InitErrorDetails]:
+        """Get the error details for the effect.
+        If task_id is not found, return an error detail.
+        """
+        errors = super()._get_error_details(method)
+
+        if not Task.objects.filter(id=self.task_id).exists():
+            errors.append(
+                self._create_error_detail(
+                    "task_id",
+                    f"Task with id: {self.task_id} does not exist.",
+                    self.task_id,
+                )
+            )
+
+        return errors
+
+
 __exports__ = (
     "AddTask",
     "AddTaskComment",
     "TaskStatus",
+    "TaskMetadata",
     "UpdateTask",
 )

canvas_sdk/effects/validation/__init__.py

@@ -0,0 +1,3 @@
+from .base import ValidationError
+
+__all__ = __exports__ = ("ValidationError",)

canvas_sdk/effects/validation/base.py

@@ -0,0 +1,92 @@
+from dataclasses import dataclass
+from typing import Any, Self
+
+from pydantic import Field
+
+from canvas_sdk.effects import EffectType
+from canvas_sdk.effects.base import _BaseEffect
+
+
+@dataclass
+class ValidationError:
+    """
+    Represents a validation error for an effect or command.
+
+    Attributes:
+        message: The validation error message to display
+    """
+
+    message: str
+
+    def __post_init__(self) -> None:
+        """
+        Validate and normalize the error message after initialization.
+
+        Raises:
+            ValueError: If message is empty
+        """
+        if not self.message or not self.message.strip():
+            raise ValueError("Error message cannot be empty")
+
+        self.message = self.message.strip()
+
+    def to_dict(self) -> dict[str, str]:
+        """Convert the validation error to a dictionary."""
+        return {"message": self.message}
+
+    def __repr__(self) -> str:
+        return f"ValidationError(message={self.message!r})"
+
+
+class _BaseValidationErrorEffect(_BaseEffect):
+    """
+    Abstract effect to abort an event.
+    """
+
+    class Meta:
+        effect_type = EffectType.UNKNOWN_EFFECT
+
+    errors: list[ValidationError] = Field(default_factory=list)
+
+    def add_error(self, message: str | ValidationError) -> Self:
+        """
+        Add a validation error to the effect.
+
+        This method allows incremental building of validation errors
+        and supports method chaining.
+
+        Args:
+            message: The error message to display, or a ValidationError object
+
+        Returns:
+            Self for method chaining
+
+        Raises:
+            ValueError: If message is empty
+
+        Example:
+            effect = CommandValidationErrorEffect()
+            effect.add_error("Narrative is required")
+            effect.add_error("Dosage must be positive")
+
+            # Using ValidationError objects
+            error = ValidationError("Already validated error")
+            effect.add_error(error)
+
+            # Method chaining
+            effect.add_error("Error 1").add_error("Error 2")
+        """
+        if isinstance(message, ValidationError):
+            self.errors.append(message)
+        else:
+            error = ValidationError(message=message)
+            self.errors.append(error)
+        return self
+
+    @property
+    def values(self) -> dict[str, Any]:
+        """Payload to include in the Effect."""
+        return {"errors": [error.to_dict() for error in self.errors]}
+
+
+__exports__ = ("ValidationError",)

canvas_sdk/events/base.py

@@ -8,6 +8,7 @@ from django.db import models
 
 from canvas_generated.messages.events_pb2 import Event as EventRequest
 from canvas_generated.messages.events_pb2 import EventType
+from canvas_sdk.v1.data import CanvasUser
 
 
 @dataclasses.dataclass
@@ -23,6 +24,18 @@ class TargetType:
         return self.type._default_manager.filter(id=self.id).first() if self.type else None
 
 
+@dataclasses.dataclass
+class Actor:
+    """The actor that triggered the event."""
+
+    id: str | None
+
+    @cached_property
+    def instance(self) -> CanvasUser | None:
+        """Return the instance of the actor."""
+        return CanvasUser._default_manager.filter(dbid=self.id).first() if self.id else None
+
+
 class Event:
     """An event that occurs in the Canvas environment."""
 
@@ -46,6 +59,8 @@ class Event:
         self.name = EventType.Name(self.type)
         self.context = context
         self.target = TargetType(id=event_request.target, type=target_model)
+        self.actor = Actor(id=event_request.actor)
+        self.source = event_request.source
 
 
 __exports__ = ("TargetType", "Event")

canvas_sdk/handlers/application.py

@@ -3,6 +3,7 @@ from abc import ABC, abstractmethod
 from canvas_sdk.effects import Effect
 from canvas_sdk.events import EventType
 from canvas_sdk.handlers import BaseHandler
+from canvas_sdk.handlers.utils import normalize_effects
 
 
 class Application(BaseHandler, ABC):
@@ -15,23 +16,22 @@ class Application(BaseHandler, ABC):
 
     def compute(self) -> list[Effect]:
         """Handle the application events."""
+        if self.event.target.id != self.identifier:
+            return []
         match self.event.type:
             case EventType.APPLICATION__ON_OPEN:
-                return [self.on_open()] if self.event.target.id == self.identifier else []
+                return normalize_effects(self.on_open())
             case EventType.APPLICATION__ON_CONTEXT_CHANGE:
-                if self.event.target.id == self.identifier:
-                    effect = self.on_context_change()
-                    return [effect] if effect is not None else []
-                return []
+                return normalize_effects(self.on_context_change())
             case _:
                 return []
 
     @abstractmethod
-    def on_open(self) -> Effect:
+    def on_open(self) -> Effect | list[Effect]:
         """Handle the application open event."""
         ...
 
-    def on_context_change(self) -> Effect | None:
+    def on_context_change(self) -> Effect | list[Effect] | None:
         """Handle the application context change event."""
         return None
 

canvas_sdk/handlers/simple_api/api.py

@@ -1,7 +1,6 @@
 import inspect
 import json
 import re
-import traceback
 from abc import ABC
 from base64 import b64decode
 from collections.abc import Callable
@@ -323,9 +322,7 @@ class SimpleAPIBase(BaseHandler, ABC):
             else:
                 raise AssertionError(f"Cannot handle event type {EventType.Name(self.event.type)}")
         except Exception as exception:
-            for error_line_with_newlines in traceback.format_exception(exception):
-                for error_line in error_line_with_newlines.split("\n"):
-                    log.error(error_line)
+            log.exception(f"Error handling '{EventType.Name(self.event.type)}' event")
 
             sentry_sdk.capture_exception(exception)
 

canvas_sdk/handlers/simple_api/websocket.py

@@ -1,4 +1,3 @@
-import traceback
 from abc import ABC
 from functools import cached_property
 from typing import ClassVar
@@ -52,9 +51,7 @@ class WebSocketAPI(BaseHandler, ABC):
             else:
                 raise AssertionError(f"Cannot handle event type {EventType.Name(self.event.type)}")
         except Exception as exception:
-            for error_line_with_newlines in traceback.format_exception(exception):
-                for error_line in error_line_with_newlines.split("\n"):
-                    log.error(error_line)
+            log.exception(f"Error handling '{EventType.Name(self.event.type)}' event")
 
             sentry_sdk.capture_exception(exception)
 

canvas_sdk/handlers/utils.py

@@ -0,0 +1,14 @@
+from canvas_sdk.effects import Effect
+
+
+def normalize_effects(effects: Effect | list[Effect] | None) -> list[Effect]:
+    """Normalize effects to a list of Effect instances."""
+    if effects is None:
+        return []
+    if isinstance(effects, Effect):
+        return [effects]
+    if isinstance(effects, list):
+        return [e for e in effects if isinstance(e, Effect)]
+
+
+__exports__ = ()

canvas_sdk/questionnaires/utils.py

@@ -121,4 +121,5 @@ __exports__ = (
     "Draft7Validator",
     "ExtendedDraft7Validator",
     "from_yaml",
+    "QuestionnaireConfig",
 )

canvas_sdk/templates/utils.py

@@ -1,11 +1,25 @@
+from functools import cache, lru_cache
 from pathlib import Path
 from typing import Any
 
-from django.template import Context, Template
+from django.template.backends.django import get_installed_libraries
+from django.template.engine import Engine
 
 from canvas_sdk.utils.plugins import plugin_context
 
 
+@cache
+def _installed_template_libraries() -> dict[str, str]:
+    """Cache Django's template tag libraries lookup."""
+    return get_installed_libraries()
+
+
+@lru_cache(maxsize=5)
+def _engine_for_plugin(plugin_dir: str) -> Engine:
+    """Create a Django template engine for the given plugin directory."""
+    return Engine(dirs=[plugin_dir], libraries=_installed_template_libraries())
+
+
 @plugin_context
 def render_to_string(
     template_name: str,
@@ -36,9 +50,8 @@ def render_to_string(
     elif not template_path.exists():
         raise FileNotFoundError(f"Template {template_name} not found.")
 
-    template = Template(template_path.read_text())
-
-    return template.render(Context(context))
+    engine = _engine_for_plugin(plugin_dir)
+    return engine.render_to_string(str(template_path), context=context)
 
 
 __exports__ = ("render_to_string",)