canvas 0.48.0__py3-none-any.whl → 0.50.0__py3-none-any.whl

canvas_sdk/commands/base.py

@@ -17,6 +17,7 @@ class _BaseCommand(TrackableFieldsModel):
         key = ""
         originate_required_fields = ("note_uuid",)
         edit_required_fields = ("command_uuid",)
+        send_required_fields = ("command_uuid",)
         delete_required_fields = ("command_uuid",)
         commit_required_fields = ("command_uuid",)
         enter_in_error_required_fields = ("command_uuid",)
@@ -161,4 +162,14 @@ class _BaseCommand(TrackableFieldsModel):
         return Recommendation(title=title, button=button, command=command, context=self.values)
 
 
-__exports__ = ("_BaseCommand",)
+class _SendableCommandMixin:
+    def send(self) -> Effect:
+        """Fire the send effect the command."""
+        self._validate_before_effect("send")  # type: ignore[attr-defined]
+        return Effect(
+            type=f"SEND_{self.constantized_key()}_COMMAND",  # type: ignore[attr-defined]
+            payload=json.dumps({"command": self.command_uuid}),  # type: ignore[attr-defined]
+        )
+
+
+__exports__ = ("_BaseCommand", "_SendableCommandMixin")

canvas_sdk/commands/commands/lab_order.py

@@ -6,10 +6,11 @@ from pydantic import Field
 from pydantic_core import InitErrorDetails
 
 from canvas_sdk.commands.base import _BaseCommand as BaseCommand
+from canvas_sdk.commands.base import _SendableCommandMixin
 from canvas_sdk.v1.data.lab import LabPartner, LabPartnerTest
 
 
-class LabOrderCommand(BaseCommand):
+class LabOrderCommand(_SendableCommandMixin, BaseCommand):
     """A class for managing a Lab Order command within a specific note."""
 
     class Meta:
@@ -29,7 +30,7 @@ class LabOrderCommand(BaseCommand):
     comment: str | None = None
 
     def _get_error_details(
-        self, method: Literal["originate", "edit", "delete", "commit", "enter_in_error"]
+        self, method: Literal["originate", "edit", "delete", "commit", "enter_in_error", "send"]
     ) -> list[InitErrorDetails]:
         errors = super()._get_error_details(method)
 
@@ -43,7 +44,11 @@ class LabOrderCommand(BaseCommand):
             else:
                 query["id"] = self.lab_partner
 
-            lab_partner_obj = LabPartner.objects.filter(**query).values("id", "dbid").first()
+            lab_partner_obj = (
+                LabPartner.objects.filter(**query)
+                .values("id", "dbid", "electronic_ordering_enabled")
+                .first()
+            )
 
             if not lab_partner_obj:
                 errors.append(

canvas_sdk/commands/commands/prescribe.py

@@ -1,13 +1,43 @@
+import json
+from dataclasses import dataclass
 from decimal import Decimal
 from enum import Enum
+from typing import Any
 
 from pydantic import Field, conlist
+from pydantic_core import InitErrorDetails
 
-from canvas_sdk.commands.base import _BaseCommand
+from canvas_sdk.commands.base import _BaseCommand, _SendableCommandMixin
 from canvas_sdk.commands.constants import ClinicalQuantity
+from canvas_sdk.effects import Effect
+from canvas_sdk.effects.compound_medications.compound_medication import (
+    CompoundMedication as CompoundMedicationEffect,
+)
+from canvas_sdk.v1.data.compound_medication import CompoundMedication as CompoundMedicationModel
+
+
+@dataclass
+class CompoundMedicationData:
+    """Data for creating a compound medication inline within a prescription."""
+
+    formulation: str
+    potency_unit_code: str
+    controlled_substance: str
+    controlled_substance_ndc: str = ""
+    active: bool = True
 
+    def to_dict(self) -> dict[str, Any]:
+        """Convert dataclass to dictionary, excluding None values."""
+        return {
+            "formulation": self.formulation,
+            "potency_unit_code": self.potency_unit_code,
+            "controlled_substance": self.controlled_substance,
+            "controlled_substance_ndc": self.controlled_substance_ndc,
+            "active": self.active,
+        }
 
-class PrescribeCommand(_BaseCommand):
+
+class PrescribeCommand(_SendableCommandMixin, _BaseCommand):
     """A class for managing a Prescribe command within a specific note."""
 
     class Meta:
@@ -36,6 +66,86 @@ class PrescribeCommand(_BaseCommand):
     )
     note_to_pharmacist: str | None = None
 
+    # Compound medication fields
+    compound_medication_id: str | None = Field(
+        default=None, json_schema_extra={"commands_api_name": "compound_medication_id"}
+    )
+    compound_medication_data: CompoundMedicationData | None = Field(
+        default=None, json_schema_extra={"commands_api_name": "compound_medication_data"}
+    )
+
+    def _get_error_details(self, method: str) -> list[InitErrorDetails]:
+        """Add compound medication validation to the base validation."""
+        errors = super()._get_error_details(method)
+
+        # Validate that exactly one medication type is provided
+        has_fdb_code = self.fdb_code is not None and self.fdb_code.strip() != ""
+        has_compound_medication_id = (
+            self.compound_medication_id is not None and self.compound_medication_id.strip() != ""
+        )
+        has_compound_medication_data = self.compound_medication_data is not None
+
+        medication_types_provided = sum(
+            [has_fdb_code, has_compound_medication_id, has_compound_medication_data]
+        )
+
+        if medication_types_provided > 1:
+            errors.append(
+                self._create_error_detail(
+                    "value",
+                    "Cannot specify multiple medication types. Choose one of: 'fdb_code', 'compound_medication_id', or 'compound_medication_data'.",
+                    None,
+                )
+            )
+
+        # Validate compound medication ID if provided
+        if (
+            self.compound_medication_id
+            and self.compound_medication_id.strip() != ""
+            and
+            # Check if compound medication exists
+            not CompoundMedicationModel.objects.filter(id=self.compound_medication_id).exists()
+        ):
+            errors.append(
+                self._create_error_detail(
+                    "value",
+                    f"Compound medication with ID {self.compound_medication_id} does not exist.",
+                    self.compound_medication_id,
+                )
+            )
+
+        # Validate compound medication data if provided
+        if self.compound_medication_data is not None:
+            compound_med_errors = CompoundMedicationEffect.validate_compound_medication_fields(
+                formulation=self.compound_medication_data.formulation,
+                potency_unit_code=self.compound_medication_data.potency_unit_code,
+                controlled_substance=self.compound_medication_data.controlled_substance,
+                controlled_substance_ndc=self.compound_medication_data.controlled_substance_ndc,
+            )
+            errors.extend(compound_med_errors)
+
+        return errors
+
+    def _process_compound_medication_fields(self, data: dict[str, Any]) -> dict[str, Any]:
+        """
+        Process compound medication fields in prescription data.
+
+        Args:
+            data: Dictionary containing prescription data
+
+        Returns:
+            Processed dictionary with compound medication transformations applied
+        """
+        # Process nested compound medication values if present
+        if "compound_medication_values" in data:
+            compound_med_data = data["compound_medication_values"]
+            processed_compound_data = CompoundMedicationEffect.process_compound_medication_data(
+                compound_med_data
+            )
+            data["compound_medication_values"] = processed_compound_data
+
+        return data
+
     @property
     def values(self) -> dict:
         """The Prescribe command's field values."""
@@ -46,11 +156,64 @@ class PrescribeCommand(_BaseCommand):
                 str(Decimal(self.quantity_to_dispense)) if self.quantity_to_dispense else None
             )
 
+        values["compound_medication_values"] = {}
+
+        if self.is_dirty("compound_medication_id") and self.compound_medication_id:
+            values["compound_medication_values"]["id"] = values.pop("compound_medication_id")
+
+        # Handle compound medication data
+        elif (
+            "compound_medication_data" in values and values["compound_medication_data"] is not None
+        ):
+            # Convert CompoundMedicationData to the expected nested structure
+            compound_data = values.pop("compound_medication_data")
+            if isinstance(compound_data, CompoundMedicationData):
+                values["compound_medication_values"] = compound_data.to_dict()
+
         return values
 
+    def originate(self, line_number: int = -1) -> Effect:
+        """Originate a new command in the note body with explicit compound medication processing."""
+        self._validate_before_effect("originate")
+
+        # Get raw values and apply explicit processing for compound medications
+        raw_data = self.values
+        processed_data = self._process_compound_medication_fields(raw_data)
+
+        return Effect(
+            type=f"ORIGINATE_{self.constantized_key()}_COMMAND",
+            payload=json.dumps(
+                {
+                    "command": self.command_uuid,
+                    "note": self.note_uuid,
+                    "data": processed_data,
+                    "line_number": line_number,
+                }
+            ),
+        )
+
+    def edit(self) -> Effect:
+        """Edit the command with explicit compound medication processing."""
+        self._validate_before_effect("edit")
+
+        # Get raw values and apply explicit processing for compound medications
+        raw_data = self.values
+        processed_data = self._process_compound_medication_fields(raw_data)
+
+        return Effect(
+            type=f"EDIT_{self.constantized_key()}_COMMAND",
+            payload=json.dumps(
+                {
+                    "command": self.command_uuid,
+                    "data": processed_data,
+                }
+            ),
+        )
+
 
 __exports__ = (
     "PrescribeCommand",
+    "CompoundMedicationData",
     # Not defined here but used in a current plugin
     "ClinicalQuantity",
     "Decimal",

canvas_sdk/effects/compound_medications/__init__.py

@@ -0,0 +1,3 @@
+from canvas_sdk.effects.compound_medications.compound_medication import CompoundMedication
+
+__all__ = __exports__ = ("CompoundMedication",)

canvas_sdk/effects/compound_medications/compound_medication.py

@@ -0,0 +1,275 @@
+import json
+from typing import Any
+
+from pydantic_core import InitErrorDetails, PydanticCustomError
+
+from canvas_generated.messages.effects_pb2 import Effect
+from canvas_sdk.base import TrackableFieldsModel
+from canvas_sdk.v1.data.compound_medication import CompoundMedication as CompoundMedicationModel
+
+
+class CompoundMedication(TrackableFieldsModel):
+    """Effect to create or update a Compound Medication record."""
+
+    class Meta:
+        effect_type = "COMPOUND_MEDICATION"
+
+    instance_id: str | None = None
+    formulation: str | None = None
+    potency_unit_code: str | None = None
+    controlled_substance: str | None = None
+    controlled_substance_ndc: str | None = None
+    active: bool | None = None
+
+    @property
+    def values(self) -> dict[str, Any]:
+        """Return the values of the compound medication as a dictionary, only including dirty (modified) fields."""
+        return super().values
+
+    @staticmethod
+    def process_formulation(formulation: str | None) -> str | None:
+        """
+        Process compound medication formulation by stripping whitespace.
+
+        Args:
+            formulation: The formulation string to process
+
+        Returns:
+            Processed formulation string, or None if input was None
+        """
+        if formulation is None:
+            return None
+        return formulation.strip()
+
+    @staticmethod
+    def process_ndc(ndc: str | None) -> str | None:
+        """
+        Process compound medication NDC by removing dashes.
+
+        Args:
+            ndc: The NDC string to process
+
+        Returns:
+            Processed NDC string with dashes removed, or None if input was None
+        """
+        if ndc is None:
+            return None
+        return ndc.replace("-", "")
+
+    @staticmethod
+    def process_compound_medication_data(data: dict[str, Any]) -> dict[str, Any]:
+        """
+        Process compound medication data by applying all necessary transformations.
+
+        Args:
+            data: Dictionary containing compound medication data
+
+        Returns:
+            Processed dictionary with transformations applied
+        """
+        processed_data = data.copy()
+
+        # Process formulation
+        if "formulation" in processed_data and processed_data["formulation"] is not None:
+            processed_data["formulation"] = CompoundMedication.process_formulation(
+                processed_data["formulation"]
+            )
+
+        # Process NDC
+        if (
+            "controlled_substance_ndc" in processed_data
+            and processed_data["controlled_substance_ndc"] is not None
+        ):
+            processed_data["controlled_substance_ndc"] = CompoundMedication.process_ndc(
+                processed_data["controlled_substance_ndc"]
+            )
+
+        return processed_data
+
+    @staticmethod
+    def validate_compound_medication_fields(
+        formulation: str | None,
+        potency_unit_code: str | None,
+        controlled_substance: str | None,
+        controlled_substance_ndc: str | None,
+    ) -> list[InitErrorDetails]:
+        """
+        Static method to validate compound medication fields.
+
+        Args:
+            formulation: The formulation value to validate
+            potency_unit_code: The potency unit code to validate
+            controlled_substance: The controlled substance to validate
+            controlled_substance_ndc: The NDC to validate
+
+        Returns:
+            List of InitErrorDetails for any validation errors
+        """
+
+        def create_error(error_type: str, message: str, value: Any) -> InitErrorDetails:
+            """Helper function to mimic _create_error_details."""
+            return InitErrorDetails(
+                {"type": PydanticCustomError(error_type, message), "input": value}
+            )
+
+        errors = []
+
+        # Formulation validation
+        if formulation is not None:
+            stripped_formulation = formulation.strip()
+            if not stripped_formulation:
+                errors.append(
+                    create_error(
+                        "value",
+                        "Field 'formulation' cannot be empty.",
+                        formulation,
+                    )
+                )
+            elif len(stripped_formulation) > 105:
+                errors.append(
+                    create_error(
+                        "value",
+                        "Field 'formulation' must be 105 characters or less.",
+                        formulation,
+                    )
+                )
+
+        # Potency unit code validation
+        if potency_unit_code and potency_unit_code not in [
+            choice[0] for choice in CompoundMedicationModel.PotencyUnits.choices
+        ]:
+            errors.append(
+                create_error(
+                    "value",
+                    f"Invalid potency unit code: {potency_unit_code}. Must be one of: {[choice[0] for choice in CompoundMedicationModel.PotencyUnits.choices]}",
+                    potency_unit_code,
+                )
+            )
+
+        # Controlled substance validation
+        if controlled_substance and controlled_substance not in [
+            choice[0] for choice in CompoundMedicationModel.ControlledSubstanceOptions.choices
+        ]:
+            errors.append(
+                create_error(
+                    "value",
+                    f"Invalid controlled substance: {controlled_substance}. Must be one of: {[choice[0] for choice in CompoundMedicationModel.ControlledSubstanceOptions.choices]}",
+                    controlled_substance,
+                )
+            )
+
+        # NDC validation - required when controlled substance is not "N" (Not Scheduled)
+        if (
+            controlled_substance
+            and controlled_substance
+            != CompoundMedicationModel.ControlledSubstanceOptions.SCHEDULE_NOT_SCHEDULED.value
+            and (not controlled_substance_ndc or not controlled_substance_ndc.strip())
+        ):
+            errors.append(
+                create_error(
+                    "value",
+                    "NDC is required when a Controlled Substance is specified.",
+                    controlled_substance_ndc,
+                )
+            )
+
+        return errors
+
+    def _get_error_details(self, method: Any) -> list[InitErrorDetails]:
+        errors = super()._get_error_details(method)
+
+        if method == "create":
+            if not self.formulation:
+                errors.append(
+                    self._create_error_detail(
+                        "missing",
+                        "Field 'formulation' is required to create a compound medication.",
+                        None,
+                    )
+                )
+
+            if not self.potency_unit_code:
+                errors.append(
+                    self._create_error_detail(
+                        "missing",
+                        "Field 'potency_unit_code' is required to create a compound medication.",
+                        None,
+                    )
+                )
+
+            if not self.controlled_substance:
+                errors.append(
+                    self._create_error_detail(
+                        "missing",
+                        "Field 'controlled_substance' is required to create a compound medication.",
+                        None,
+                    )
+                )
+
+        elif method == "update":
+            if not self.instance_id:
+                errors.append(
+                    self._create_error_detail(
+                        "missing",
+                        "Field 'instance_id' is required to update a compound medication.",
+                        None,
+                    )
+                )
+
+        if (
+            self.instance_id
+            and not CompoundMedicationModel.objects.filter(id=self.instance_id).exists()
+        ):
+            errors.append(
+                self._create_error_detail(
+                    "value",
+                    f"Compound medication with ID {self.instance_id} does not exist.",
+                    self.instance_id,
+                )
+            )
+
+        compound_med_errors = self.validate_compound_medication_fields(
+            formulation=self.formulation,
+            potency_unit_code=self.potency_unit_code,
+            controlled_substance=self.controlled_substance,
+            controlled_substance_ndc=self.controlled_substance_ndc,
+        )
+        errors.extend(compound_med_errors)
+
+        return errors
+
+    def create(self) -> Effect:
+        """Create a new Compound Medication."""
+        self._validate_before_effect("create")
+
+        # Get raw values and apply explicit processing
+        raw_data = self.values
+        processed_data = self.process_compound_medication_data(raw_data)
+
+        payload = {"data": processed_data}
+        if self.active is None:
+            payload["data"]["active"] = True
+
+        return Effect(
+            type=f"CREATE_{self.Meta.effect_type}",
+            payload=json.dumps(payload),
+        )
+
+    def update(self) -> Effect:
+        """Update an existing Compound Medication."""
+        self._validate_before_effect("update")
+
+        # Get raw values and apply explicit processing
+        raw_data = self.values
+        processed_data = self.process_compound_medication_data(raw_data)
+
+        payload = {"data": processed_data}
+        payload["data"]["instance_id"] = str(self.instance_id)
+
+        return Effect(
+            type=f"UPDATE_{self.Meta.effect_type}",
+            payload=json.dumps(payload),
+        )
+
+
+__exports__ = ("CompoundMedication",)

canvas_sdk/v1/data/__init__.py

@@ -9,6 +9,7 @@ from .charge_description_master import ChargeDescriptionMaster
 from .claim import Claim, ClaimCoverage, ClaimPatient, ClaimQueue, InstallmentPlan
 from .claim_line_item import ClaimLineItem
 from .command import Command
+from .compound_medication import CompoundMedication
 from .condition import Condition, ConditionCoding
 from .coverage import Coverage, Transactor, TransactorAddress, TransactorPhone
 from .detected_issue import DetectedIssue, DetectedIssueEvidence
@@ -107,6 +108,7 @@ __all__ = __exports__ = (
     "ClaimPatient",
     "ClaimQueue",
     "Command",
+    "CompoundMedication",
     "Condition",
     "ConditionCoding",
     "Coverage",

canvas_sdk/v1/data/compound_medication.py

@@ -0,0 +1,67 @@
+from django.db import models
+from django.db.models import TextChoices
+
+
+class CompoundMedication(models.Model):
+    """CompoundMedication."""
+
+    class Meta:
+        managed = False
+        db_table = "canvas_sdk_data_api_compoundmedication_001"
+
+    class PotencyUnits(TextChoices):
+        """Potency Units."""
+
+        APPLICATOR = "C62412", "Applicator"
+        BLISTER = "C54564", "Blister"
+        CAPLET = "C64696", "Caplet"
+        CAPSULE = "C48480", "Capsule"
+        EACH = "C64933", "Each"
+        FILM = "C53499", "Film"
+        GRAM = "C48155", "Gram"
+        GUM = "C69124", "Gum"
+        IMPLANT = "C48499", "Implant"
+        INSERT = "C62276", "Insert"
+        KIT = "C48504", "Kit"
+        LANCET = "C120263", "Lancet"
+        LOZENGE = "C48506", "Lozenge"
+        MILLILITER = "C28254", "Milliliter"
+        PACKET = "C48521", "Packet"
+        PAD = "C65032", "Pad"
+        PATCH = "C48524", "Patch"
+        PEN_NEEDLE = "C120216", "Pen Needle"
+        RING = "C62609", "Ring"
+        SPONGE = "C53502", "Sponge"
+        STICK = "C53503", "Stick"
+        STRIP = "C48538", "Strip"
+        SUPPOSITORY = "C48539", "Suppository"
+        SWAB = "C53504", "Swab"
+        TABLET = "C48542", "Tablet"
+        TROCHE = "C48548", "Troche"
+        UNSPECIFIED = "C38046", "Unspecified"
+        WAFER = "C48552", "Wafer"
+
+    class ControlledSubstanceOptions(TextChoices):
+        """Controlled Substance Options."""
+
+        SCHEDULE_NOT_SCHEDULED = "N", "None"
+        SCHEDULE_II = "II", "Schedule II"
+        SCHEDULE_III = "III", "Schedule III"
+        SCHEDULE_IV = "IV", "Schedule IV"
+        SCHEDULE_V = "V", "Schedule V"
+
+    id = models.UUIDField()
+    dbid = models.BigIntegerField(primary_key=True)
+    active = models.BooleanField(default=True)
+    formulation = models.CharField(max_length=105)
+    potency_unit_code = models.CharField(max_length=20, choices=PotencyUnits.choices)
+    controlled_substance = models.CharField(
+        max_length=3, choices=ControlledSubstanceOptions.choices
+    )
+    controlled_substance_ndc = models.CharField(max_length=20, blank=True, default="")
+
+    def __str__(self) -> str:
+        return f'CompoundMedication: "{self.formulation}"'
+
+
+__exports__ = ("CompoundMedication",)

plugin_runner/allowed-module-imports.json

@@ -43,7 +43,8 @@
     "VitalsCommand"
   ],
   "canvas_sdk.commands.base": [
-    "_BaseCommand"
+    "_BaseCommand",
+    "_SendableCommandMixin"
   ],
   "canvas_sdk.commands.commands.adjust_prescription": [
     "AdjustPrescriptionCommand"
@@ -112,6 +113,7 @@
   ],
   "canvas_sdk.commands.commands.prescribe": [
     "ClinicalQuantity",
+    "CompoundMedicationData",
     "Decimal",
     "PrescribeCommand"
   ],
@@ -204,6 +206,12 @@
   "canvas_sdk.effects.billing_line_item.update_billing_line_item": [
     "UpdateBillingLineItem"
   ],
+  "canvas_sdk.effects.compound_medications": [
+    "CompoundMedication"
+  ],
+  "canvas_sdk.effects.compound_medications.compound_medication": [
+    "CompoundMedication"
+  ],
   "canvas_sdk.effects.launch_modal": [
     "LaunchModalEffect"
   ],
@@ -491,6 +499,7 @@
     "ClaimPatient",
     "ClaimQueue",
     "Command",
+    "CompoundMedication",
     "Condition",
     "ConditionCoding",
     "Coverage",
@@ -640,6 +649,9 @@
     "ReviewStatus",
     "TaxIDType"
   ],
+  "canvas_sdk.v1.data.compound_medication": [
+    "CompoundMedication"
+  ],
   "canvas_sdk.v1.data.condition": [
     "ClinicalStatus",
     "Condition",

plugin_runner/sandbox.py

@@ -216,8 +216,15 @@ THIRD_PARTY_MODULES = {
     "jwt": {
         "decode",
         "encode",
+        "PyJWKClient",
+        "ExpiredSignatureError",
+        "InvalidTokenError",
     },
     "pydantic": {
+        "BaseModel",
+        "conint",
+        "constr",
+        "Field",
         "ValidationError",
     },
     "rapidfuzz": {