canvas 0.2.11__py3-none-any.whl → 0.3.1__py3-none-any.whl

canvas_sdk/data/task.py

@@ -8,6 +8,8 @@ from canvas_sdk.effects import Effect, EffectType
 
 
 class Task(DataModel):
+    """Data model for a task."""
+
     class Meta(DataModel.Meta):
         create_required_fields = ("title",)
 
@@ -26,15 +28,18 @@ class Task(DataModel):
     labels: list[str] | None = None
 
     def create(self) -> Effect:
+        """Return an effect to create the task."""
         self._validate_before_effect("create")
         return Effect(type=EffectType.CREATE_TASK, payload=self.model_dump_json_nested())
 
     def update(self) -> Effect:
+        """Return an effect to update the task."""
         self._validate_before_effect("update")
         payload = self.model_dump_json_nested(exclude_unset=True)
         return Effect(type=EffectType.UPDATE_TASK, payload=payload)
 
     def add_comment(self, comment: str) -> Effect:
+        """Return an effect to add a comment to the task."""
         if not self.id:
             raise ValueError("Cannot add a comment to a Task without an id")
         task_comment = TaskComment(task=self, body=comment)
@@ -46,6 +51,8 @@ class Task(DataModel):
 
 
 class TaskComment(DataModel):
+    """Data model for a task comment."""
+
     class Meta:
         create_required_fields = (
             "body",

canvas_sdk/effects/protocol_card/protocol_card.py

@@ -50,6 +50,7 @@ class ProtocolCard(_BaseEffect):
     narrative: str = ""
     recommendations: list[Recommendation] = []
     status: Status = Status.DUE  # type: ignore
+    feedback_enabled: bool = False
 
     @property
     def values(self) -> dict[str, Any]:
@@ -61,6 +62,7 @@ class ProtocolCard(_BaseEffect):
                 rec.values | {"key": i} for i, rec in enumerate(self.recommendations)
             ],
             "status": self.status.value,
+            "feedback_enabled": self.feedback_enabled,
         }
 
     @property

canvas_sdk/effects/protocol_card/tests.py

@@ -1,3 +1,5 @@
+from typing import Any
+
 import pytest
 from pydantic import ValidationError
 
@@ -23,7 +25,7 @@ def test_apply_method_succeeds_with_patient_id_and_key() -> None:
     applied = p.apply()
     assert (
         applied.payload
-        == '{"patient": "uuid", "key": "something-unique", "data": {"title": "", "narrative": "", "recommendations": [], "status": "due"}}'
+        == '{"patient": "uuid", "key": "something-unique", "data": {"title": "", "narrative": "", "recommendations": [], "status": "due", "feedback_enabled": false}}'
     )
 
 
@@ -105,7 +107,7 @@ def test_apply_method_raises_error_without_patient_id_and_key() -> None:
     ],
 )
 def test_add_recommendations(
-    init_params: dict[str, str], rec1_params: dict[str, str], rec2_params: dict[str, str]
+    init_params: dict[str, str], rec1_params: dict[Any, Any], rec2_params: dict[str, str]
 ) -> None:
     p = ProtocolCard(**init_params)
     p.add_recommendation(**rec1_params)
@@ -133,6 +135,7 @@ def test_add_recommendations(
             },
         ],
         "status": "due",
+        "feedback_enabled": False,
     }
 
 

canvas_sdk/protocols/__init__.py

@@ -1 +1,2 @@
 from canvas_sdk.protocols.base import BaseProtocol
+from canvas_sdk.protocols.clinical_quality_measure import ClinicalQualityMeasure

canvas_sdk/protocols/clinical_quality_measure.py

@@ -14,6 +14,7 @@ class ClinicalQualityMeasure(BaseProtocol):
         description: str = ""
         information: str = ""
         references: list[str] = []
+        source_attributes: dict[str, str]
         types: list[str] = []
         authors: list[str] = []
         show_in_chart: bool = True

canvas_sdk/utils/http.py

@@ -1,6 +1,6 @@
 import time
 from functools import wraps
-from typing import Any, Callable, TypeVar
+from typing import Any, Callable, Mapping, TypeVar
 
 import requests
 import statsd
@@ -16,26 +16,27 @@ class Http:
         self.statsd_client = statsd.StatsClient()
 
     @staticmethod
-    def measure_time(fn: F | None = None) -> Callable[[F], F] | F:
+    def measure_time(fn: F) -> F:
         """A decorator to store timing of HTTP calls."""
 
-        def _decorator(fn: F) -> F:
-            @wraps(fn)
-            def wrapper(self: "Http", *args: Any, **kwargs: Any) -> Any:
-                start_time = time.time()
-                result = fn(self, *args, **kwargs)
-                end_time = time.time()
-                timing = int((end_time - start_time) * 1000)
-                self.statsd_client.timing(f"http_{fn.__name__}", timing)
-                return result
+        @wraps(fn)
+        def wrapper(self: "Http", *args: Any, **kwargs: Any) -> Any:
+            start_time = time.time()
+            result = fn(self, *args, **kwargs)
+            end_time = time.time()
+            timing = int((end_time - start_time) * 1000)
+            self.statsd_client.timing(f"http_{fn.__name__}", timing)
+            return result
 
-            return wrapper
-
-        return _decorator(fn) if fn else _decorator
+        return wrapper
 
     @measure_time
-    def get(self, url: str, headers: dict = {}) -> requests.Response:
+    def get(
+        self, url: str, headers: Mapping[str, str | bytes | None] | None = None
+    ) -> requests.Response:
         """Sends a GET request."""
+        if headers is None:
+            headers = {}
         return self.session.get(url, headers=headers)
 
     @measure_time
@@ -44,7 +45,7 @@ class Http:
         url: str,
         json: dict | None = None,
         data: dict | str | list | bytes | None = None,
-        headers: dict = {},
+        headers: Mapping[str, str | bytes | None] | None = None,
     ) -> requests.Response:
         """Sends a POST request."""
         return self.session.post(url, json=json, data=data, headers=headers)
@@ -55,7 +56,7 @@ class Http:
         url: str,
         json: dict | None = None,
         data: dict | str | list | bytes | None = None,
-        headers: dict = {},
+        headers: Mapping[str, str | bytes | None] | None = None,
     ) -> requests.Response:
         """Sends a PUT request."""
         return self.session.put(url, json=json, data=data, headers=headers)
@@ -66,7 +67,7 @@ class Http:
         url: str,
         json: dict | None = None,
         data: dict | str | list | bytes | None = None,
-        headers: dict = {},
+        headers: Mapping[str, str | bytes | None] | None = None,
     ) -> requests.Response:
         """Sends a PATCH request."""
         return self.session.patch(url, json=json, data=data, headers=headers)

canvas_sdk/utils/stats.py

@@ -2,7 +2,8 @@ from time import time
 from typing import Any
 
 
-def get_duration_ms(start_time: time) -> int:
+def get_duration_ms(start_time: float) -> int:
+    """Get the duration in milliseconds since the given start time."""
     return int((time() - start_time) * 1000)
 
 

canvas_sdk/v1/data/allergy_intolerance.py

@@ -1,7 +1,7 @@
 from django.contrib.postgres.fields import ArrayField
 from django.db import models
 
-from canvas_sdk.v1.data.base import CommittableModelManager
+from canvas_sdk.v1.data.base import CommittableModelManager, ValueSetLookupQuerySet
 from canvas_sdk.v1.data.patient import Patient
 from canvas_sdk.v1.data.user import CanvasUser
 
@@ -14,13 +14,12 @@ class AllergyIntolerance(models.Model):
         app_label = "canvas_sdk"
         db_table = "canvas_sdk_data_api_allergyintolerance_001"
 
-    objects = CommittableModelManager()
+    objects = CommittableModelManager().from_queryset(ValueSetLookupQuerySet)()
 
     id = models.UUIDField()
     dbid = models.BigIntegerField(primary_key=True)
     created = models.DateTimeField()
     modified = models.DateTimeField()
-    editors = ArrayField(models.IntegerField())
     deleted = models.BooleanField()
     committer = models.ForeignKey(CanvasUser, on_delete=models.DO_NOTHING)
     entered_in_error = models.ForeignKey(CanvasUser, on_delete=models.DO_NOTHING)

canvas_sdk/v1/data/base.py

@@ -1,4 +1,5 @@
-from typing import TYPE_CHECKING, Type
+from collections.abc import Container
+from typing import TYPE_CHECKING, Type, cast
 
 from django.db import models
 from django.db.models import Q
@@ -8,19 +9,26 @@ if TYPE_CHECKING:
 
 
 class CommittableModelManager(models.Manager):
+    """A manager for commands that can be committed."""
+
     def get_queryset(self) -> "models.QuerySet":
+        """Return a queryset that filters out deleted objects."""
         # TODO: Should we just filter these out at the view level?
         return super().get_queryset().filter(deleted=False)
 
     def committed(self) -> "models.QuerySet":
+        """Return a queryset that filters for objects that have been committed."""
         # The committer_id IS set, and the entered_in_error_id IS NOT set
         return self.filter(committer_id__isnull=False, entered_in_error_id__isnull=True)
 
     def for_patient(self, patient_id: str) -> "models.QuerySet":
+        """Return a queryset that filters objects for a specific patient."""
         return self.filter(patient__id=patient_id)
 
 
 class ValueSetLookupQuerySet(models.QuerySet):
+    """A QuerySet that can filter objects based on a ValueSet."""
+
     def find(self, value_set: Type["ValueSet"]) -> models.QuerySet:
         """
         Filters conditions, medications, etc. to those found in the inherited ValueSet class that is passed.
@@ -35,13 +43,51 @@ class ValueSetLookupQuerySet(models.QuerySet):
 
         Condition.objects.find(MorbidObesity).find(AnaphylacticReactionToCommonBakersYeast)
         """
-        values_dict = value_set.values
-        uri_codes = [
-            (i[1], values_dict[i[0]])
-            for i in value_set.CODE_SYSTEM_MAPPING.items()
-            if i[0] in values_dict
-        ]
         q_filter = Q()
-        for system, codes in uri_codes:
-            q_filter |= Q(codings__system=system, codings__code__in=codes)
+        for system, codes in self.codings(value_set):
+            q_filter |= self.q_object(system, codes)
         return self.filter(q_filter).distinct()
+
+    @staticmethod
+    def codings(value_set: Type["ValueSet"]) -> tuple[tuple[str, set[str]]]:
+        """Provide a sequence of tuples where each tuple is a code system URL and a set of codes."""
+        values_dict = value_set.values
+        return cast(
+            tuple[tuple[str, set[str]]],
+            tuple(
+                (i[1], values_dict[i[0]])
+                for i in value_set.CODE_SYSTEM_MAPPING.items()
+                if i[0] in values_dict
+            ),
+        )
+
+    @staticmethod
+    def q_object(system: str, codes: Container[str]) -> Q:
+        """
+        This method can be overridden if a Q object with different filtering options is needed.
+        """
+        return Q(codings__system=system, codings__code__in=codes)
+
+
+class ValueSetLookupByNameQuerySet(ValueSetLookupQuerySet):
+    """
+    QuerySet for ValueSet lookups using code system name rather than URL.
+
+    Some models, like Questionnaire, store the code system by name (e.g. "LOINC") rather than by the
+    url (e.g. "http://loinc.org"). This subclass accommodates these models.
+    """
+
+    @staticmethod
+    def codings(value_set: Type["ValueSet"]) -> tuple[tuple[str, set[str]]]:
+        """
+        Provide a sequence of tuples where each tuple is a code system name and a set of codes.
+        """
+        values_dict = value_set.values
+        return cast(
+            tuple[tuple[str, set[str]]],
+            tuple(
+                (i[0], values_dict[i[0]])
+                for i in value_set.CODE_SYSTEM_MAPPING.items()
+                if i[0] in values_dict
+            ),
+        )

canvas_sdk/v1/data/command.py

@@ -0,0 +1,27 @@
+from django.db import models
+
+from canvas_sdk.v1.data.patient import Patient
+from canvas_sdk.v1.data.user import CanvasUser
+
+
+class Command(models.Model):
+    """Command."""
+
+    class Meta:
+        managed = False
+        app_label = "canvas_sdk"
+        db_table = "canvas_sdk_data_commands_command_001"
+
+    id = models.UUIDField()
+    dbid = models.BigIntegerField(primary_key=True)
+    created = models.DateTimeField()
+    modified = models.DateTimeField()
+    originator = models.ForeignKey(CanvasUser, on_delete=models.DO_NOTHING)
+    committer = models.ForeignKey(CanvasUser, on_delete=models.DO_NOTHING)
+    entered_in_error = models.ForeignKey(CanvasUser, on_delete=models.DO_NOTHING)
+    state = models.CharField()
+    patient = models.ForeignKey(Patient, on_delete=models.DO_NOTHING)
+    note_id = models.BigIntegerField()
+    schema_key = models.TextField()
+    data = models.JSONField()
+    origination_source = models.CharField()

canvas_sdk/v1/data/device.py

@@ -0,0 +1,44 @@
+from django.db import models
+
+from canvas_sdk.v1.data import Patient
+from canvas_sdk.v1.data.user import CanvasUser
+
+
+class Device(models.Model):
+    """Device."""
+
+    class Meta:
+        managed = False
+        app_label = "canvas_sdk"
+        db_table = "canvas_sdk_data_api_device_001"
+
+    id = models.UUIDField()
+    dbid = models.BigIntegerField(primary_key=True)
+    created = models.DateTimeField()
+    modified = models.DateTimeField()
+    originator = models.ForeignKey(CanvasUser, on_delete=models.DO_NOTHING)
+    committer = models.ForeignKey(CanvasUser, on_delete=models.DO_NOTHING)
+    entered_in_error = models.ForeignKey(CanvasUser, on_delete=models.DO_NOTHING)
+    patient = models.ForeignKey(Patient, on_delete=models.DO_NOTHING, related_name="devices")
+    note_id = models.BigIntegerField()
+    deleted = models.BooleanField()
+    labeled_contains_NRL = models.BooleanField()
+    assigning_authority = models.CharField()
+    scoping_entity = models.CharField()
+    udi = models.CharField()
+    di = models.CharField()
+    issuing_agency = models.CharField()
+    lot_number = models.CharField()
+    brand_name = models.CharField()
+    mri_safety_status = models.CharField()
+    version_model_number = models.CharField()
+    company_name = models.CharField()
+    gmdnPTName = models.TextField()
+    status = models.CharField()
+    expiration_date = models.DateField()
+    expiration_date_original = models.CharField()
+    serial_number = models.CharField()
+    manufacturing_date_original = models.CharField()
+    manufacturing_date = models.DateField()
+    manufacturer = models.CharField()
+    procedure_id = models.BigIntegerField()

canvas_sdk/v1/data/lab.py

@@ -6,6 +6,8 @@ from canvas_sdk.v1.data.user import CanvasUser
 
 
 class LabReport(models.Model):
+    """A class representing a lab report."""
+
     class Meta:
         managed = False
         app_label = "canvas_sdk"
@@ -38,6 +40,8 @@ class LabReport(models.Model):
 
 
 class LabReview(models.Model):
+    """A class representing a lab review."""
+
     class Meta:
         managed = False
         app_label = "canvas_sdk"
@@ -61,6 +65,8 @@ class LabReview(models.Model):
 
 
 class LabValue(models.Model):
+    """A class representing a lab value."""
+
     class Meta:
         managed = False
         app_label = "canvas_sdk"
@@ -82,6 +88,8 @@ class LabValue(models.Model):
 
 
 class LabValueCoding(models.Model):
+    """A class representing a lab value coding."""
+
     class Meta:
         managed = False
         app_label = "canvas_sdk"

canvas_sdk/v1/data/observation.py

@@ -0,0 +1,117 @@
+from django.db import models
+
+from canvas_sdk.v1.data.base import CommittableModelManager, ValueSetLookupQuerySet
+from canvas_sdk.v1.data.patient import Patient
+from canvas_sdk.v1.data.user import CanvasUser
+
+
+class ObservationQuerySet(ValueSetLookupQuerySet):
+    """ObservationQuerySet."""
+
+    pass
+
+
+class Observation(models.Model):
+    """Observation."""
+
+    class Meta:
+        managed = False
+        app_label = "canvas_sdk"
+        db_table = "canvas_sdk_data_api_observation_001"
+
+    objects = CommittableModelManager.from_queryset(ObservationQuerySet)()
+
+    id = models.UUIDField()
+    dbid = models.BigIntegerField(primary_key=True)
+    created = models.DateTimeField()
+    modified = models.DateTimeField()
+    originator = models.ForeignKey(CanvasUser, on_delete=models.DO_NOTHING)
+    committer = models.ForeignKey(CanvasUser, on_delete=models.DO_NOTHING)
+    entered_in_error = models.ForeignKey(CanvasUser, on_delete=models.DO_NOTHING)
+    deleted = models.BooleanField()
+    patient = models.ForeignKey(Patient, on_delete=models.DO_NOTHING, related_name="observations")
+    is_member_of = models.ForeignKey(
+        "self", on_delete=models.DO_NOTHING, null=True, related_name="members"
+    )
+    category = models.CharField()
+    units = models.TextField()
+    value = models.TextField()
+    note_id = models.BigIntegerField()
+    name = models.TextField()
+    effective_datetime = models.DateTimeField()
+
+
+class ObservationCoding(models.Model):
+    """ObservationCoding."""
+
+    class Meta:
+        managed = False
+        app_label = "canvas_sdk"
+        db_table = "canvas_sdk_data_api_observationcoding_001"
+
+    dbid = models.BigIntegerField(primary_key=True)
+    system = models.CharField()
+    version = models.CharField()
+    code = models.CharField()
+    display = models.CharField()
+    user_selected = models.BooleanField()
+    observation = models.ForeignKey(
+        Observation, on_delete=models.DO_NOTHING, related_name="codings"
+    )
+
+
+class ObservationComponent(models.Model):
+    """ObservationComponent."""
+
+    class Meta:
+        managed = False
+        app_label = "canvas_sdk"
+        db_table = "canvas_sdk_data_api_observationcomponent_001"
+
+    dbid = models.BigIntegerField(primary_key=True)
+    created = models.DateTimeField()
+    modified = models.DateTimeField()
+    observation = models.ForeignKey(
+        Observation, on_delete=models.DO_NOTHING, related_name="components"
+    )
+    value_quantity = models.TextField()
+    value_quantity_unit = models.TextField()
+    name = models.TextField()
+
+
+class ObservationComponentCoding(models.Model):
+    """ObservationComponentCoding."""
+
+    class Meta:
+        managed = False
+        app_label = "canvas_sdk"
+        db_table = "canvas_sdk_data_api_observationcomponentcoding_001"
+
+    dbid = models.BigIntegerField(primary_key=True)
+    system = models.CharField()
+    version = models.CharField()
+    code = models.CharField()
+    display = models.CharField()
+    user_selected = models.BooleanField()
+    observation_component = models.ForeignKey(
+        ObservationComponent, on_delete=models.DO_NOTHING, related_name="codings"
+    )
+
+
+class ObservationValueCoding(models.Model):
+    """ObservationValueCoding."""
+
+    class Meta:
+        managed = False
+        app_label = "canvas_sdk"
+        db_table = "canvas_sdk_data_api_observationvaluecoding_001"
+
+    dbid = models.BigIntegerField(primary_key=True)
+    system = models.CharField()
+    version = models.CharField()
+    code = models.CharField()
+    display = models.CharField()
+    user_selected = models.BooleanField()
+    observation = models.ForeignKey(
+        Observation, on_delete=models.DO_NOTHING, related_name="value_codings"
+    )

canvas_sdk/v1/data/patient.py

@@ -4,6 +4,8 @@ from django.db import models
 
 
 class Patient(models.Model):
+    """A class representing a patient."""
+
     class Meta:
         managed = False
         app_label = "canvas_sdk"
@@ -46,4 +48,5 @@ class Patient(models.Model):
 
     @classmethod
     def find(cls, id: str) -> Self:
+        """Find a patient by id."""
         return cls.objects.get(id=id)