canvas 0.5.0__py3-none-any.whl → 0.7.0__py3-none-any.whl

canvas_sdk/effects/task/task.py

@@ -0,0 +1,99 @@
+from datetime import datetime
+from enum import Enum
+from typing import Any, cast
+
+from canvas_sdk.effects.base import EffectType, _BaseEffect
+
+
+class TaskStatus(Enum):
+    """TaskStatus."""
+
+    COMPLETED = "COMPLETED"
+    CLOSED = "CLOSED"
+    OPEN = "OPEN"
+
+
+class AddTask(_BaseEffect):
+    """
+    An Effect that will create a Task in Canvas.
+    """
+
+    class Meta:
+        effect_type = EffectType.CREATE_TASK
+        apply_required_fields = ("title",)
+
+    assignee_id: str | None = None
+    patient_id: str | None = None
+    title: str | None = None
+    due: datetime | None = None
+    status: TaskStatus = TaskStatus.OPEN
+    labels: list[str] = []
+
+    @property
+    def values(self) -> dict[str, Any]:
+        """The values for Task addition."""
+        return {
+            "patient": {"id": self.patient_id},
+            "due": self.due.isoformat() if self.due else None,
+            "assignee": {"id": self.assignee_id},
+            "title": self.title,
+            "status": self.status.value,
+            "labels": self.labels,
+        }
+
+
+class AddTaskComment(_BaseEffect):
+    """
+    An Effect that will create a Task Comment on a Task.
+    """
+
+    class Meta:
+        effect_type = EffectType.CREATE_TASK_COMMENT
+        apply_required_fields = (
+            "body",
+            "task_id",
+        )
+
+    body: str | None = None
+    task_id: str | None = None
+
+    @property
+    def values(self) -> dict[str, Any]:
+        """The values for adding a task comment."""
+        return {"task": {"id": self.task_id}, "body": self.body}
+
+
+class UpdateTask(_BaseEffect):
+    """
+    An Effect that will update a Task in Canvas.
+    """
+
+    class Meta:
+        effect_type = EffectType.UPDATE_TASK
+        apply_required_fields = ("id",)
+
+    id: str | None = None
+    assignee_id: str | None = None
+    patient_id: str | None = None
+    title: str | None = None
+    due: datetime | None = None
+    status: TaskStatus = TaskStatus.OPEN
+    labels: list[str] = []
+
+    @property
+    def values(self) -> dict[str, Any]:
+        """The values for adding a task comment."""
+        value_dict: dict[str, Any] = {}
+        # Only add the fields that have been explicitly set on the model (exclude_unset=True).
+        # Oherwise, the effect interpreter will set values to null based on their defaults.
+        set_fields = self.model_dump(exclude_unset=True)
+        for field, val in set_fields.items():
+            if field.endswith("_id"):
+                value_dict[field.split("_")[0]] = {"id": val}
+            elif field == "due" and val is not None:
+                value_dict[field] = cast(datetime, val).isoformat()
+            elif field == "status":
+                value_dict[field] = cast(TaskStatus, val).value
+            else:
+                value_dict[field] = getattr(self, field)
+        return value_dict

canvas_sdk/protocols/base.py

@@ -1,6 +1,5 @@
 from typing import Any
 
-from canvas_sdk.data.client import GQL_CLIENT
 from canvas_sdk.handlers.base import BaseHandler
 
 
@@ -9,13 +8,4 @@ class BaseProtocol(BaseHandler):
     The class that protocols inherit from.
     """
 
-    def _beta_run_gql_query(self, query: str, variables: dict | None = None) -> dict[str, Any]:
-        return GQL_CLIENT.query(
-            query,
-            variables=variables,
-            extra_args={
-                "headers": {
-                    "Authorization": f'Bearer {self.secrets["graphql_jwt"]}',
-                },
-            },
-        )
+    pass

canvas_sdk/protocols/clinical_quality_measure.py

@@ -1,6 +1,13 @@
-from typing import Any
+from typing import Any, cast
 
+import arrow
+from django.db.models import Model
+
+from canvas_sdk.events import EventType
 from canvas_sdk.protocols.base import BaseProtocol
+from canvas_sdk.protocols.timeframe import Timeframe
+from canvas_sdk.v1.data.condition import Condition
+from canvas_sdk.v1.data.medication import Medication
 
 
 class ClinicalQualityMeasure(BaseProtocol):
@@ -23,6 +30,11 @@ class ClinicalQualityMeasure(BaseProtocol):
         is_abstract: bool = False
         is_predictive: bool = False
 
+    def __init__(self, *args: Any, **kwargs: Any):
+        self._patient_id: str | None = None
+        self.now = arrow.utcnow()
+        super().__init__(*args, **kwargs)
+
     @classmethod
     def _meta(cls) -> dict[str, Any]:
         """
@@ -41,3 +53,47 @@ class ClinicalQualityMeasure(BaseProtocol):
         External key used to identify the protocol.
         """
         return cls.__name__
+
+    @property
+    def timeframe(self) -> Timeframe:
+        """The default Timeframe (self.timeframe) for all protocols.
+        This defaults to have a start of 1 year ago and an end time of the current time.
+        Plugin authors can override this if a different timeframe is desired.
+        """
+        end = self.now
+        return Timeframe(start=end.shift(years=-1), end=end)
+
+    # TODO: This approach should be considered against the alternative of just including the patient
+    #  ID in the event context, given that so many events will be patient-centric.
+    def patient_id_from_target(self) -> str:
+        """
+        Get and return the patient ID from an event target.
+
+        This method will attempt to obtain the patient ID from the event target for supported event
+        types. It stores the patient ID on a member variable so that it can be referenced without
+        incurring more SQL queries.
+        """
+
+        def patient_id(model: type[Model]) -> str:
+            return cast(
+                str,
+                model._default_manager.select_related("patient")
+                .values_list("patient__id")
+                .get(id=self.event.target)[0],
+            )
+
+        if not self._patient_id:
+            # TODO: Add cases for ProtocolOverride
+            match self.event.type:
+                case EventType.CONDITION_CREATED | EventType.CONDITION_UPDATED:
+                    self._patient_id = patient_id(Condition)
+                case (
+                    EventType.MEDICATION_LIST_ITEM_CREATED | EventType.MEDICATION_LIST_ITEM_UPDATED
+                ):
+                    self._patient_id = patient_id(Medication)
+                case _:
+                    raise AssertionError(
+                        f"Event type {self.event.type} not supported by 'patient_id_from_event'"
+                    )
+
+        return self._patient_id

canvas_sdk/protocols/timeframe.py

@@ -0,0 +1,39 @@
+import arrow
+
+
+class Timeframe:
+    """A class representing a timeframe with a start and and end."""
+
+    def __init__(self, start: arrow.Arrow, end: arrow.Arrow):
+        self.start = start
+        self.end = end
+
+    def __str__(self) -> str:
+        return f"<Timeframe start={self.start}, end={self.end}>"
+
+    @property
+    def duration(self) -> int:
+        """Returns the number of days in the timeframe."""
+        return (self.end - self.start).days
+
+    def increased_by(self, years: int = 0, months: int = 0, days: int = 0) -> "Timeframe":
+        """Returns a new Timeframe object increased by the years, months, days in the arguments."""
+        start = self.start
+        end = self.end
+
+        if years > 0:
+            end = end.shift(years=years)
+        elif years < 0:
+            start = start.shift(years=years)
+
+        if months > 0:
+            end = end.shift(months=months)
+        elif months < 0:
+            start = start.shift(months=months)
+
+        if days > 0:
+            end = end.shift(days=days)
+        elif days < 0:
+            start = start.shift(days=days)
+
+        return Timeframe(start=start, end=end)

canvas_sdk/v1/data/__init__.py

@@ -1,3 +1,6 @@
+from .billing import BillingLineItem
 from .condition import Condition, ConditionCoding
 from .medication import Medication, MedicationCoding
 from .patient import Patient
+from .staff import Staff
+from .task import Task, TaskComment, TaskLabel

canvas_sdk/v1/data/base.py

@@ -1,35 +1,70 @@
+from abc import abstractmethod
 from collections.abc import Container
-from typing import TYPE_CHECKING, Type, cast
+from typing import TYPE_CHECKING, Any, Protocol, Self, Type, cast
 
 from django.db import models
 from django.db.models import Q
 
 if TYPE_CHECKING:
+    from canvas_sdk.protocols.timeframe import Timeframe
     from canvas_sdk.value_set.value_set import ValueSet
 
 
 class CommittableModelManager(models.Manager):
     """A manager for commands that can be committed."""
 
-    def get_queryset(self) -> "models.QuerySet":
+    def get_queryset(self) -> "CommittableQuerySet":
         """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)
+        return CommittableQuerySet(self.model, using=self._db).filter(deleted=False)
 
-    def committed(self) -> "models.QuerySet":
+
+class CommittableQuerySet(models.QuerySet):
+    """A queryset for committable objects."""
+
+    def committed(self) -> "Self":
         """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":
+    def for_patient(self, patient_id: str) -> "Self":
         """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."""
+class BaseQuerySet(models.QuerySet):
+    """A base QuerySet inherited from Django's model.Queryset."""
+
+    pass
+
+
+class QuerySetProtocol(Protocol):
+    """A typing protocol for use in mixins into models.QuerySet-inherited classes."""
 
-    def find(self, value_set: Type["ValueSet"]) -> models.QuerySet:
+    def filter(self, *args: Any, **kwargs: Any) -> models.QuerySet[Any]:
+        """Django's models.QuerySet filter method."""
+        ...
+
+
+class ValueSetLookupQuerySetProtocol(QuerySetProtocol):
+    """A typing protocol for use in mixins using value set lookup methods."""
+
+    @staticmethod
+    @abstractmethod
+    def codings(value_set: Type["ValueSet"]) -> tuple[tuple[str, set[str]]]:
+        """A protocol method for defining codings."""
+        raise NotImplementedError
+
+    @staticmethod
+    @abstractmethod
+    def q_object(system: str, codes: Container[str]) -> Q:
+        """A protocol method for defining Q objects for value set lookups."""
+        raise NotImplementedError
+
+
+class ValueSetLookupQuerySetMixin(ValueSetLookupQuerySetProtocol):
+    """A QuerySet mixin that can filter objects based on a ValueSet."""
+
+    def find(self, value_set: Type["ValueSet"]) -> models.QuerySet[Any]:
         """
         Filters conditions, medications, etc. to those found in the inherited ValueSet class that is passed.
 
@@ -51,7 +86,7 @@ class ValueSetLookupQuerySet(models.QuerySet):
     @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
+        values_dict = cast(dict, value_set.values)
         return cast(
             tuple[tuple[str, set[str]]],
             tuple(
@@ -69,7 +104,7 @@ class ValueSetLookupQuerySet(models.QuerySet):
         return Q(codings__system=system, codings__code__in=codes)
 
 
-class ValueSetLookupByNameQuerySet(ValueSetLookupQuerySet):
+class ValueSetLookupByNameQuerySetMixin(ValueSetLookupQuerySetMixin):
     """
     QuerySet for ValueSet lookups using code system name rather than URL.
 
@@ -82,7 +117,7 @@ class ValueSetLookupByNameQuerySet(ValueSetLookupQuerySet):
         """
         Provide a sequence of tuples where each tuple is a code system name and a set of codes.
         """
-        values_dict = value_set.values
+        values_dict = cast(dict, value_set.values)
         return cast(
             tuple[tuple[str, set[str]]],
             tuple(
@@ -91,3 +126,51 @@ class ValueSetLookupByNameQuerySet(ValueSetLookupQuerySet):
                 if i[0] in values_dict
             ),
         )
+
+
+class TimeframeLookupQuerySetProtocol(QuerySetProtocol):
+    """A typing protocol for use in TimeframeLookupQuerySetMixin."""
+
+    @property
+    @abstractmethod
+    def timeframe_filter_field(self) -> str:
+        """A protocol method for timeframe_filter_field."""
+        raise NotImplementedError
+
+
+class TimeframeLookupQuerySetMixin(TimeframeLookupQuerySetProtocol):
+    """A class that adds queryset functionality to filter using timeframes."""
+
+    @property
+    def timeframe_filter_field(self) -> str:
+        """Returns the field that should be filtered on. Can be overridden for different models."""
+        return "note__datetime_of_service"
+
+    def within(self, timeframe: "Timeframe") -> models.QuerySet:
+        """A method to filter a queryset for datetimes within a timeframe."""
+        return self.filter(
+            **{
+                f"{self.timeframe_filter_field}__range": (
+                    timeframe.start.datetime,
+                    timeframe.end.datetime,
+                )
+            }
+        )
+
+
+class ValueSetLookupQuerySet(BaseQuerySet, ValueSetLookupQuerySetMixin):
+    """A class that includes methods for looking up value sets."""
+
+    pass
+
+
+class ValueSetLookupByNameQuerySet(BaseQuerySet, ValueSetLookupByNameQuerySetMixin):
+    """A class that includes methods for looking up value sets by name."""
+
+    pass
+
+
+class ValueSetTimeframeLookupQuerySet(ValueSetLookupQuerySet, TimeframeLookupQuerySetMixin):
+    """A class that includes methods for looking up value sets and using timeframes."""
+
+    pass

canvas_sdk/v1/data/billing.py

@@ -0,0 +1,59 @@
+from typing import TYPE_CHECKING, Type
+
+from django.db import models
+
+from canvas_sdk.v1.data.base import ValueSetTimeframeLookupQuerySet
+from canvas_sdk.v1.data.note import Note
+from canvas_sdk.v1.data.patient import Patient
+from canvas_sdk.value_set.value_set import CodeConstants
+
+if TYPE_CHECKING:
+    from canvas_sdk.value_set.value_set import ValueSet
+
+
+class BillingLineItemQuerySet(ValueSetTimeframeLookupQuerySet):
+    """A class that adds functionality to filter BillingLineItem objects."""
+
+    def find(self, value_set: Type["ValueSet"]) -> models.QuerySet:
+        """
+        This method is overridden to use for BillingLineItem CPT codes.
+        The codes are saved as string values in the BillingLineItem.cpt field,
+        which differs from other coding models.
+        """
+        values_dict = value_set.values
+        return self.filter(cpt__in=values_dict.get(CodeConstants.HCPCS, []))
+
+
+class BillingLineItemStatus(models.TextChoices):
+    """Billing line item status."""
+
+    ACTIVE = "active", "Active"
+    REMOVED = "removed", "Removed"
+
+
+class BillingLineItem(models.Model):
+    """BillingLineItem."""
+
+    class Meta:
+        managed = False
+        app_label = "canvas_sdk"
+        db_table = "canvas_sdk_data_api_billinglineitem_001"
+
+    # objects = BillingLineItemQuerySet.as_manager()
+    objects = models.Manager().from_queryset(BillingLineItemQuerySet)()
+
+    id = models.UUIDField()
+    dbid = models.BigIntegerField(primary_key=True)
+    created = models.DateTimeField()
+    modified = models.DateTimeField()
+    note = models.ForeignKey(Note, on_delete=models.DO_NOTHING, related_name="billing_line_items")
+    patient = models.ForeignKey(
+        Patient, on_delete=models.DO_NOTHING, related_name="billing_line_items"
+    )
+    cpt = models.CharField()
+    charge = models.DecimalField()
+    description = models.CharField()
+    units = models.IntegerField()
+    command_type = models.CharField()
+    command_id = models.IntegerField()
+    status = models.CharField(choices=BillingLineItemStatus.choices)

canvas_sdk/v1/data/common.py

@@ -1,3 +1,4 @@
+from django.contrib.postgres.fields import ArrayField
 from django.db import models
 
 
@@ -44,3 +45,60 @@ class ReviewStatus(models.TextChoices):
 
     STATUS_REVIEWING = "reviewing", "reviewing"
     STATUS_REVIEWED = "reviewed", "reviewed"
+
+
+class PersonSex(models.TextChoices):
+    """Status choices for individual sex."""
+
+    SEX_FEMALE = "F", "female"
+    SEX_MALE = "M", "male"
+    SEX_OTHER = "O", "other"
+    SEX_UNKNOWN = "UNK", "unknown"
+    SEX_BLANK = "", ""
+
+
+class TaxIDType(models.TextChoices):
+    """Choices for Tax IDs."""
+
+    EIN = "E", "EIN text"
+    SSN = "S", "SSN"
+
+
+class ColorEnum(models.TextChoices):
+    """Choices for colors."""
+
+    RED = "red", "Red"
+    ORANGE = "orange", "Orange"
+    YELLOW = "yellow", "Yellow"
+    OLIVE = "olive", "Olive"
+    GREEN = "green", "Green"
+    TEAL = "teal", "Teal"
+    BLUE = "blue", "Blue"
+    VIOLET = "violet", "Violet"
+    PURPLE = "purple", "Purple"
+    PINK = "pink", "Pink"
+    BROWN = "brown", "Brown"
+    GREY = "grey", "Grey"
+    BLACK = "black", "Black"
+
+
+class Origin(models.TextChoices):
+    """Choices for origins."""
+
+    REFERAL = ("REF_CMD", "Referral command")
+    COMPLETING_IMAGE_ORDERS = ("CMP_IMG_ORD", "Completing image orders")
+    IMAGING_REPORT_REVIEW = ("IMG_REP_REV", "Imaging report review")
+    LAB_RESULTS_REVIEW = ("LAB_RES_REV", "Lab results review")
+    CONSULT_REPORT_REVIEW = ("CON_REP_REV", "Consult report review")
+    UNCATEGORIZED_DOCUMENT_REPORT_REVIEW = (
+        "UNC_DOC_REP_REV",
+        "Uncategorized document report review",
+    )
+    ASSIGNED_NOTE_PHONE_CALL_FOR_REVIEW = ("ASN_NOT_PHN_REV", "Assigned note/phone call for review")
+    POPULATION_HEALTH_OUTREACH = ("POP_HLT_OUT", "Population health outreach")
+    COMPLETING_LAB_ORDERS = ("CMP_LAB_ORD", "Completing lab orders")
+    CHART_PDF = ("CHT_PDF", "Chart PDF")
+    EXPIRED_CLAIM_SNOOZED = ("EXP_CLM_SNO", "Expired claim snoozed")
+    FLAGGED_POSTING_REVIEW = ("FLG_PST_REV", "Flagged posting review")
+    BATCH_PATIENT_STATEMENTS = ("BAT_PTN_STA", "Batch patient statements")
+    INCOMPLETE_COVERAGE = ("INC_COV", "Incomplete Coverage")

canvas_sdk/v1/data/condition.py

@@ -1,10 +1,25 @@
 from django.db import models
+from django.db.models import TextChoices
 
-from canvas_sdk.v1.data.base import CommittableModelManager, ValueSetLookupQuerySet
+from canvas_sdk.v1.data.base import (
+    CommittableModelManager,
+    CommittableQuerySet,
+    ValueSetLookupQuerySet,
+)
 from canvas_sdk.v1.data.patient import Patient
 from canvas_sdk.v1.data.user import CanvasUser
 
 
+class ClinicalStatus(TextChoices):
+    """Condition clinical status."""
+
+    ACTIVE = "active", "active"
+    RELAPSE = "relapse", "relapse"
+    REMISSION = "remission", "remission"
+    RESOLVED = "resolved", "resolved"
+    INVESTIGATIVE = "investigative", "investigative"
+
+
 class ConditionQuerySet(ValueSetLookupQuerySet):
     """ConditionQuerySet."""
 
@@ -19,12 +34,13 @@ class Condition(models.Model):
         app_label = "canvas_sdk"
         db_table = "canvas_sdk_data_api_condition_001"
 
-    objects = CommittableModelManager.from_queryset(ConditionQuerySet)()
+    objects = ConditionQuerySet.as_manager()
 
     id = models.UUIDField()
     dbid = models.BigIntegerField(primary_key=True)
     onset_date = models.DateField()
     resolution_date = models.DateField()
+    clinical_status = models.CharField(choices=ClinicalStatus.choices)
     deleted = models.BooleanField()
     entered_in_error = models.ForeignKey(CanvasUser, on_delete=models.DO_NOTHING)
     committer = models.ForeignKey(CanvasUser, on_delete=models.DO_NOTHING)

canvas_sdk/v1/data/medication.py

@@ -1,10 +1,18 @@
 from django.db import models
+from django.db.models import TextChoices
 
 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 Status(TextChoices):
+    """Medication status."""
+
+    ACTIVE = "active", "active"
+    INACTIVE = "inactive", "inactive"
+
+
 class MedicationQuerySet(ValueSetLookupQuerySet):
     """MedicationQuerySet."""
 
@@ -27,9 +35,9 @@ class Medication(models.Model):
     deleted = models.BooleanField()
     entered_in_error = models.ForeignKey(CanvasUser, on_delete=models.DO_NOTHING)
     committer = models.ForeignKey(CanvasUser, on_delete=models.DO_NOTHING)
-    status = models.CharField()
-    start_date = models.DateField()
-    end_date = models.DateField()
+    status = models.CharField(choices=Status.choices)
+    start_date = models.DateTimeField()
+    end_date = models.DateTimeField()
     quantity_qualifier_description = models.CharField()
     clinical_quantity_description = models.CharField()
     potency_unit_code = models.CharField()