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

canvas_sdk/v1/data/lab.py

@@ -1,10 +1,21 @@
 from django.db import models
 
 from canvas_sdk.v1.data.base import CommittableModelManager
+from canvas_sdk.v1.data.condition import Condition
 from canvas_sdk.v1.data.patient import Patient
+
+# from canvas_sdk.v1.data.staff import Staff
 from canvas_sdk.v1.data.user import CanvasUser
 
 
+class TransmissionType(models.TextChoices):
+    """Choices for transmission types."""
+
+    FAX = "F", "fax"
+    HL7 = "H", "hl7"
+    MANUAL = "M", "manual"
+
+
 class LabReport(models.Model):
     """A class representing a lab report."""
 
@@ -23,19 +34,23 @@ class LabReport(models.Model):
     junked = models.BooleanField()
     requires_signature = models.BooleanField()
     assigned_date = models.DateTimeField()
-    patient = models.ForeignKey(Patient, on_delete=models.DO_NOTHING, related_name="lab_reports")
-    transmission_type = models.CharField()
+    patient = models.ForeignKey(
+        Patient, on_delete=models.DO_NOTHING, related_name="lab_reports", null=True
+    )
+    transmission_type = models.CharField(choices=TransmissionType)
     for_test_only = models.BooleanField()
     external_id = models.CharField()
     version = models.IntegerField()
     requisition_number = models.CharField()
-    review = models.ForeignKey("LabReview", related_name="reports", on_delete=models.DO_NOTHING)
+    review = models.ForeignKey(
+        "LabReview", related_name="reports", on_delete=models.DO_NOTHING, null=True
+    )
     original_date = models.DateTimeField()
     date_performed = models.DateTimeField()
     custom_document_name = models.CharField()
     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)
+    committer = models.ForeignKey(CanvasUser, on_delete=models.DO_NOTHING, null=True)
+    entered_in_error = models.ForeignKey(CanvasUser, on_delete=models.DO_NOTHING, null=True)
     deleted = models.BooleanField()
 
 
@@ -55,12 +70,12 @@ class LabReview(models.Model):
     modified = models.DateTimeField()
     originator = models.ForeignKey(CanvasUser, on_delete=models.DO_NOTHING)
     deleted = models.BooleanField()
-    committer = models.ForeignKey(CanvasUser, on_delete=models.DO_NOTHING)
-    entered_in_error = models.ForeignKey(CanvasUser, on_delete=models.DO_NOTHING)
+    committer = models.ForeignKey(CanvasUser, on_delete=models.DO_NOTHING, null=True)
+    entered_in_error = models.ForeignKey(CanvasUser, on_delete=models.DO_NOTHING, null=True)
     internal_comment = models.TextField()
     message_to_patient = models.CharField()
     status = models.CharField()
-    patient = models.ForeignKey(Patient, on_delete=models.DO_NOTHING)
+    patient = models.ForeignKey(Patient, on_delete=models.DO_NOTHING, related_name="lab_reviews")
     patient_communication_method = models.CharField()
 
 
@@ -76,7 +91,9 @@ class LabValue(models.Model):
     dbid = models.BigIntegerField(primary_key=True)
     created = models.DateTimeField()
     modified = models.DateTimeField()
-    report = models.ForeignKey("LabReport", related_name="values", on_delete=models.DO_NOTHING)
+    report = models.ForeignKey(
+        "LabReport", related_name="values", on_delete=models.DO_NOTHING, null=True
+    )
     value = models.TextField()
     units = models.CharField()
     abnormal_flag = models.CharField()
@@ -98,7 +115,162 @@ class LabValueCoding(models.Model):
     dbid = models.BigIntegerField(primary_key=True)
     created = models.DateTimeField()
     modified = models.DateTimeField()
-    value = models.ForeignKey(LabValue, on_delete=models.DO_NOTHING, related_name="codings")
+    value = models.ForeignKey(
+        LabValue, on_delete=models.DO_NOTHING, related_name="codings", null=True
+    )
     code = models.CharField()
     name = models.CharField()
     system = models.CharField()
+
+
+class LabOrder(models.Model):
+    """A class representing a lab order."""
+
+    class SpecimenCollectionType(models.TextChoices):
+        """Choices for specimen collection types."""
+
+        ON_LOCATION = "L", "on location"
+        PATIENT_SERVICE_CENTER = "P", "patient service center"
+        OTHER = "O", "other"
+
+    class CourtesyCopyType(models.TextChoices):
+        """Choices for courtesy copy types."""
+
+        ACCOUNT = "A", "account"
+        FAX = "F", "fax"
+        PATIENT = "P", "patient"
+
+    class ManualProcessingStatus(models.TextChoices):
+        """Choices for manual processing statuses."""
+
+        MANUAL_PROCESSING_STATUS_NEEDS_REVIEW = "NEEDS_REVIEW", "Needs Review"
+        MANUAL_PROCESSING_STATUS_IN_PROGRESS = "IN_PROGRESS", "In Progress"
+        MANUAL_PROCESSING_STATUS_PROCESSED = "PROCESSED", "Processed"
+        MANUAL_PROCESSING_STATUS_FLAGGED = "FLAGGED", "Flagged"
+
+    class Meta:
+        managed = False
+        app_label = "canvas_sdk"
+        db_table = "canvas_sdk_data_api_laborder_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)
+    deleted = models.BooleanField()
+    committer = models.ForeignKey(CanvasUser, on_delete=models.DO_NOTHING, null=True)
+    entered_in_error = models.ForeignKey(CanvasUser, on_delete=models.DO_NOTHING, null=True)
+    patient = models.ForeignKey(Patient, on_delete=models.DO_NOTHING, related_name="lab_orders")
+    ontology_lab_partner = models.CharField()
+    # TODO - uncomment when the Note model is finished
+    # note = models.ForeignKey("Note", on_delete=models.DO_NOTHING)
+    comment = models.CharField()
+    requisition_number = models.CharField()
+    is_patient_bill = models.BooleanField(null=True)
+    date_ordered = models.DateTimeField()
+    fasting_status = models.BooleanField(null=True)
+    specimen_collection_type = models.CharField(choices=SpecimenCollectionType, null=True)
+    transmission_type = models.CharField(choices=TransmissionType, null=True)
+    courtesy_copy_type = models.CharField(choices=CourtesyCopyType, null=True)
+    courtesy_copy_number = models.CharField()
+    courtesy_copy_text = models.CharField()
+    # TODO - uncomment when Staff model is added
+    # ordering_provider = models.ForeignKey(Staff, on_delete=models.DO_NOTHING, null=True)
+    parent_order = models.ForeignKey("LabOrder", on_delete=models.DO_NOTHING, null=True)
+    healthgorilla_id = models.CharField()
+    manual_processing_status = models.CharField(choices=ManualProcessingStatus)
+    manual_processing_comment = models.CharField()
+    labcorp_abn_url = models.URLField()
+
+
+class LabOrderReason(models.Model):
+    """A class representing a lab order reason."""
+
+    class LabReasonMode(models.TextChoices):
+        """Choices for lab order reasons."""
+
+        MONITOR = "MO", "monitor"
+        INVESTIGATE = "IN", "investigate"
+        SCREEN_FOR = "SF", "screen for"
+        UNKNOWN = "UNK", "unknown"
+
+    class Meta:
+        managed = False
+        app_label = "canvas_sdk"
+        db_table = "canvas_sdk_data_api_laborderreason_001"
+
+    dbid = models.BigIntegerField(primary_key=True)
+    created = models.DateTimeField()
+    modified = models.DateTimeField()
+    originator = models.ForeignKey(CanvasUser, on_delete=models.DO_NOTHING)
+    deleted = models.BooleanField()
+    committer = models.ForeignKey(CanvasUser, on_delete=models.DO_NOTHING)
+    entered_in_error = models.ForeignKey(CanvasUser, on_delete=models.DO_NOTHING)
+    order = models.ForeignKey(LabOrder, on_delete=models.DO_NOTHING, related_name="reasons")
+    mode = models.CharField(max_length=30, choices=LabReasonMode)
+
+
+class LabOrderReasonCondition(models.Model):
+    """A class representing a lab order reason's condition."""
+
+    class Meta:
+        managed = False
+        app_label = "canvas_sdk"
+        db_table = "canvas_sdk_data_api_laborderreasoncondition_001"
+
+    dbid = models.BigIntegerField(primary_key=True)
+    created = models.DateTimeField()
+    modified = models.DateTimeField()
+    reason = models.ForeignKey(
+        LabOrderReason, on_delete=models.DO_NOTHING, related_name="reason_conditions", null=True
+    )
+    condition = models.ForeignKey(
+        Condition,
+        on_delete=models.DO_NOTHING,
+        related_name="lab_order_reason_conditions",
+        null=True,
+    )
+
+
+class LabTest(models.Model):
+    """A class representing a lab test."""
+
+    class LabTestOrderStatus(models.TextChoices):
+        """Choicees for lab test order statuses."""
+
+        NEW = "NE", "new"
+        STAGED_FOR_REQUISITION = "SR", "staged for requisition"
+        SENDING = "SE", "sending"
+        SENDING_FAILED = "SF", "sending failed"
+        PROCESSING = "PR", "processing"
+        PROCESSING_FAILED = "PF", "processing failed"
+        RECEIVED = "RE", "received"
+        REVIEWED = "RV", "reviewed"
+        INACTIVE = "IN", "inactive"
+
+    class Meta:
+        managed = False
+        app_label = "canvas_sdk"
+        db_table = "canvas_sdk_data_api_labtest_001"
+
+    id = models.UUIDField()
+    dbid = models.BigIntegerField(primary_key=True)
+    ontology_test_name = models.CharField(max_length=512, blank=True, default="")
+    ontology_test_code = models.CharField(max_length=512, blank=True, default="")
+    status = models.CharField(max_length=30, choices=LabTestOrderStatus)
+    report = models.ForeignKey(
+        LabReport, on_delete=models.DO_NOTHING, null=True, related_name="tests"
+    )
+    aoe_code = models.CharField(max_length=10, default="")
+    procedure_class = models.CharField(max_length=10, default="")
+    specimen_type = models.CharField()
+    specimen_source_code = models.CharField()
+    specimen_source_description = models.CharField()
+    specimen_source_coding_system = models.CharField()
+    order = models.ForeignKey(
+        LabOrder, on_delete=models.DO_NOTHING, related_name="tests", null=True
+    )
+
+    def __str__(self) -> str:
+        return f"{self.ontology_test_name}: f{self.ontology_test_code}"

canvas_sdk/v1/data/patient.py

@@ -49,4 +49,7 @@ class Patient(models.Model):
     @classmethod
     def find(cls, id: str) -> Self:
         """Find a patient by id."""
-        return cls.objects.get(id=id)
+        return cls._default_manager.get(id=id)
+
+    def __str__(self) -> str:
+        return f"{self.first_name} {self.last_name}"

canvas_sdk/v1/data/questionnaire.py

@@ -109,7 +109,7 @@ class Questionnaire(models.Model):
     code_system = models.CharField()
     code = models.CharField()
     search_tags = models.CharField()
-    questions = models.ManyToManyField(Question, through="QuestionnaireQuestionMap")
+    questions = models.ManyToManyField(Question, through="canvas_sdk.QuestionnaireQuestionMap")  # type: ignore[misc, var-annotated]
     use_in_shx = models.BooleanField()
     carry_forward = models.TextField()
 
@@ -152,7 +152,9 @@ class Interview(models.Model):
     patient = models.ForeignKey(Patient, on_delete=models.DO_NOTHING, related_name="interviews")
     note_id = models.BigIntegerField()
     appointment_id = models.BigIntegerField()
-    questionnaires = models.ManyToManyField(Questionnaire, through="InterviewQuestionnaireMap")
+    questionnaires = models.ManyToManyField(  # type: ignore[var-annotated]
+        Questionnaire, through="canvas_sdk.InterviewQuestionnaireMap"  # type: ignore[misc]
+    )
     progress_status = models.CharField()
     created = models.DateTimeField()
     modified = models.DateTimeField()

canvas_sdk/value_set/tests/test_value_sets.py

@@ -1,11 +1,10 @@
-import pytest
-
 from canvas_sdk.value_set.v2022.condition import (
     DisordersOfTheImmuneSystem,
     EncephalopathyDueToChildhoodVaccination,
     Rhabdomyolysis,
     StableAndUnstableAngina,
 )
+from canvas_sdk.value_set.value_set import CombinedValueSet
 
 
 def test_value_set_class_values_property() -> None:
@@ -15,7 +14,9 @@ def test_value_set_class_values_property() -> None:
 
 
 def test_value_set_class_pipe_operator_with_two_value_sets() -> None:
-    combined_value_set = DisordersOfTheImmuneSystem | EncephalopathyDueToChildhoodVaccination
+    combined_value_set: CombinedValueSet = (
+        DisordersOfTheImmuneSystem | EncephalopathyDueToChildhoodVaccination
+    )
 
     both_classes_icd_10_codes = DisordersOfTheImmuneSystem.ICD10CM.union(
         EncephalopathyDueToChildhoodVaccination.ICD10CM
@@ -29,7 +30,7 @@ def test_value_set_class_pipe_operator_with_two_value_sets() -> None:
 
 
 def test_value_set_class_pipe_operator_with_three_value_sets() -> None:
-    combined_value_set = (
+    combined_value_set: CombinedValueSet = (
         DisordersOfTheImmuneSystem | EncephalopathyDueToChildhoodVaccination | Rhabdomyolysis
     )
 
@@ -45,8 +46,10 @@ def test_value_set_class_pipe_operator_with_three_value_sets() -> None:
 
 
 def test_value_set_class_pipe_operator_with_two_combined_value_sets() -> None:
-    combined_value_set_1 = DisordersOfTheImmuneSystem | EncephalopathyDueToChildhoodVaccination
-    combined_value_set_2 = Rhabdomyolysis | StableAndUnstableAngina
+    combined_value_set_1: CombinedValueSet = (
+        DisordersOfTheImmuneSystem | EncephalopathyDueToChildhoodVaccination
+    )
+    combined_value_set_2: CombinedValueSet = Rhabdomyolysis | StableAndUnstableAngina
 
     combined_value_set = combined_value_set_1 | combined_value_set_2
 

canvas_sdk/value_set/v2022/intervention.py

@@ -1,30 +1,6 @@
 from ..value_set import ValueSet
 
 
-class HospiceCareAmbulatory(ValueSet):
-    """
-    **Clinical Focus:** The purpose of this value set is to represent concepts of interventions to identify patients receiving hospice care outside of a hospital or long term care facility.
-
-    **Data Element Scope:** This value set may use a model element related to Procedure or Intervention.
-
-    **Inclusion Criteria:** Includes concepts that represent a procedure or intervention for hospice care.
-
-    **Exclusion Criteria:** Excludes concepts that represent palliative care or comfort measures.
-
-    ** Used in:** CMS90v11, CMS134v10, CMS165v10, CMS146v10, CMS124v10, CMS139v10, CMS154v10, CMS56v10, CMS74v11, CMS75v10, CMS137v10, CMS136v11, CMS128v10, CMS122v10, CMS153v10, CMS66v10, CMS130v10, CMS155v10, CMS127v10, CMS117v10, CMS131v10, CMS156v10, CMS125v10
-    """
-
-    VALUE_SET_NAME = "Hospice care ambulatory"
-    OID = "2.16.840.1.113762.1.4.1108.15"
-    DEFINITION_VERSION = "20170504"
-    EXPANSION_VERSION = "eCQM Update 2021-05-06"
-
-    SNOMEDCT = {
-        "385763009",  # Hospice care (regime/therapy)
-        "385765002",  # Hospice care management (procedure)
-    }
-
-
 class PalliativeCareIntervention(ValueSet):
     """
     **Clinical Focus:** The purpose of this value set is to represent concepts for palliative care interventions.

canvas_sdk/value_set/value_set.py

@@ -1,5 +1,7 @@
 from collections import defaultdict
-from typing import Dict, Union, cast
+from typing import Union, cast
+
+from django.utils.functional import classproperty
 
 
 class CodeConstants:
@@ -33,7 +35,7 @@ class CodeConstants:
     URL_NDC = "http://hl7.org/fhir/sid/ndc"
 
 
-class CodeConstantsURLMapping:
+class CodeConstantsURLMappingMixin:
     """A class that maps code systems to their URLs."""
 
     CODE_SYSTEM_MAPPING = {
@@ -53,21 +55,21 @@ class CodeConstantsURLMapping:
     }
 
 
-class CombinedValueSet(CodeConstantsURLMapping):
+class CombinedValueSet(CodeConstantsURLMappingMixin):
     """A class representing a combination of two value sets."""
 
     def __init__(
         self,
-        value_set_1: Union["ValueSet", "CombinedValueSet"],
-        value_set_2: Union["ValueSet", "CombinedValueSet"],
+        value_set_1: Union[type["ValueSet"], "CombinedValueSet"],
+        value_set_2: Union[type["ValueSet"], "CombinedValueSet"],
     ) -> None:
         self.value_set_1 = value_set_1
         self.value_set_2 = value_set_2
 
     @property
-    def values(self) -> Dict[str, set]:
+    def values(self) -> dict[str, set]:
         """A property that returns the combined values from both value sets."""
-        values: Dict[str, set] = defaultdict(set)
+        values: dict[str, set] = defaultdict(set)
 
         for vs in [self.value_set_1, self.value_set_2]:
             sub_values = vs.values
@@ -77,7 +79,7 @@ class CombinedValueSet(CodeConstantsURLMapping):
 
         return values
 
-    def __or__(self, value_set: Union["ValueSet", "CombinedValueSet"]) -> "CombinedValueSet":
+    def __or__(self, value_set: Union[type["ValueSet"], "CombinedValueSet"]) -> "CombinedValueSet":
         """Implements the `|` (or) operator to combine value sets."""
         return CombinedValueSet(self, value_set)
 
@@ -85,22 +87,23 @@ class CombinedValueSet(CodeConstantsURLMapping):
 class ValueSystems(type):
     """A metaclass for defining a ValueSet."""
 
-    @property
-    def values(cls) -> dict[str, set]:
-        """A property that returns a dictionary of code systems and their associated values."""
-        return {
-            system: getattr(cls, system)
-            for system in cast(ValueSet, cls).CODE_SYSTEM_MAPPING.keys()
-            if hasattr(cls, system)
-        }
+    def __or__(self, value_set: Union[type["ValueSet"], "CombinedValueSet"]) -> "CombinedValueSet":  # type: ignore[override]
+        """Implements the `|` (or) operator."""
+        return CombinedValueSet(cast(type["ValueSet"], self), value_set)
 
-    def __or__(self, value_set: Union["ValueSet", "CombinedValueSet"]) -> CombinedValueSet:  # type: ignore[override]
+    def __ror__(self, value_set: Union[type["ValueSet"], "CombinedValueSet"]) -> "CombinedValueSet":  # type: ignore[override]
         """Implements the `|` (or) operator."""
-        return CombinedValueSet(cast(ValueSet, self), value_set)
+        return self.__or__(value_set)
 
 
-class ValueSet(CodeConstantsURLMapping, metaclass=ValueSystems):
+class ValueSet(CodeConstantsURLMappingMixin, metaclass=ValueSystems):
     """The Base class for a ValueSet."""
 
-    values: dict[str, set]
-    pass
+    @classproperty
+    def values(cls) -> dict[str, set]:
+        """A property that returns a dictionary of code systems and their associated values."""
+        return {
+            system: getattr(cls, system)
+            for system in cls.CODE_SYSTEM_MAPPING.keys()
+            if hasattr(cls, system)
+        }

plugin_runner/plugin_runner.py

@@ -9,7 +9,7 @@ import time
 import traceback
 from collections import defaultdict
 from types import FrameType
-from typing import Any, Optional
+from typing import Any, AsyncGenerator, Optional, TypedDict, cast
 
 import grpc
 import statsd
@@ -54,6 +54,49 @@ LOADED_PLUGINS: dict = {}
 EVENT_PROTOCOL_MAP: dict = {}
 
 
+class DataAccess(TypedDict):
+    """DataAccess."""
+
+    event: str
+    read: list[str]
+    write: list[str]
+
+
+Protocol = TypedDict(
+    "Protocol",
+    {
+        "class": str,
+        "data_access": DataAccess,
+    },
+)
+
+
+class Components(TypedDict):
+    """Components."""
+
+    protocols: list[Protocol]
+    commands: list[dict]
+    content: list[dict]
+    effects: list[dict]
+    views: list[dict]
+
+
+class PluginManifest(TypedDict):
+    """PluginManifest."""
+
+    sdk_version: str
+    plugin_version: str
+    name: str
+    description: str
+    components: Components
+    secrets: list[dict]
+    tags: dict[str, str]
+    references: list[str]
+    license: str
+    diagram: bool
+    readme: str
+
+
 class PluginRunner(PluginRunnerServicer):
     """This process runs provided plugins that register interest in incoming events."""
 
@@ -63,12 +106,20 @@ class PluginRunner(PluginRunnerServicer):
 
     sandbox: Sandbox
 
-    async def HandleEvent(self, request: Event, context: Any) -> EventResponse:
+    async def HandleEvent(
+        self, request: Event, context: Any
+    ) -> AsyncGenerator[EventResponse, None]:
         """This is invoked when an event comes in."""
         event_start_time = time.time()
-        event_name = EventType.Name(request.type)
+        event_type = request.type
+        event_name = EventType.Name(event_type)
         relevant_plugins = EVENT_PROTOCOL_MAP.get(event_name, [])
 
+        if event_type in [EventType.PLUGIN_CREATED, EventType.PLUGIN_UPDATED]:
+            plugin_name = request.target
+            # filter only for the plugin(s) that were created/updated
+            relevant_plugins = [p for p in relevant_plugins if p.startswith(f"{plugin_name}:")]
+
         effect_list = []
 
         for plugin_name in relevant_plugins:
@@ -129,7 +180,7 @@ class PluginRunner(PluginRunnerServicer):
 
     async def ReloadPlugins(
         self, request: ReloadPluginsRequest, context: Any
-    ) -> ReloadPluginsResponse:
+    ) -> AsyncGenerator[ReloadPluginsResponse, None]:
         """This is invoked when we need to reload plugins."""
         try:
             load_plugins()
@@ -166,13 +217,13 @@ def load_or_reload_plugin(path: pathlib.Path) -> None:
     log.info(f"Loading {path}")
 
     manifest_file = path / MANIFEST_FILE_NAME
-    manifest_json = manifest_file.read_text()
+    manifest_json_str = manifest_file.read_text()
 
     # the name is the folder name underneath the plugins directory
     name = path.name
 
     try:
-        manifest_json = json.loads(manifest_json)
+        manifest_json: PluginManifest = json.loads(manifest_json_str)
     except Exception as e:
         log.error(f'Unable to load plugin "{name}": {e}')
         return
@@ -264,8 +315,8 @@ def load_plugins(specified_plugin_paths: list[str] | None = None) -> None:
         for plugin_path in plugin_paths:
             # when we import plugins we'll use the module name directly so we need to add the plugin
             # directory to the path
-            path_to_append = f"./{plugin_path.parent}"
-            sys.path.append(path_to_append)
+            path_to_append = pathlib.Path(".") / plugin_path.parent
+            sys.path.append(path_to_append.as_posix())
     else:
         candidates = os.listdir(PLUGIN_DIRECTORY)
 

plugin_runner/sandbox.py

@@ -113,7 +113,7 @@ class Sandbox:
             => 'from _a import x' is ok, because '_a' is not added to the scope.
             """
             for name in node.names:
-                if "*" in name.name and not _is_known_module(node.module):
+                if "*" in name.name and node.module and not _is_known_module(node.module):
                     self.error(node, '"*" imports are not allowed.')
                 self.check_name(node, name.name)
                 if name.asname: