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

canvas_sdk/clients/llms/structures/settings/llm_settings_gemini.py

@@ -0,0 +1,40 @@
+from dataclasses import dataclass
+
+from canvas_sdk.clients.llms.structures.settings.llm_settings import LlmSettings
+
+
+@dataclass
+class LlmSettingsGemini(LlmSettings):
+    """Configuration settings for Google Gemini LLM API.
+
+    Extends LlmSettings with Gemini-specific parameters.
+
+    Attributes:
+        api_key: API authentication key for the LLM service (inherited).
+        model: Name or identifier of the LLM model to use (inherited).
+        temperature: Controls randomness in responses (0.0-1.0).
+
+    Example:
+        ```python3
+        LlmSettingsGemini(
+            api_key=environ.get("google_key"),
+            model="models/gemini-2.0-flash",
+            temperature=2.0,
+        )
+        ```
+    """
+
+    temperature: float
+
+    def to_dict(self) -> dict:
+        """Convert settings to Google Gemini API request format.
+
+        Returns:
+            Dictionary containing model name and generationConfig with temperature.
+        """
+        return super().to_dict() | {
+            "generationConfig": {"temperature": self.temperature},
+        }
+
+
+__exports__ = ("LlmSettingsGemini",)

canvas_sdk/clients/llms/structures/settings/llm_settings_gpt4.py

@@ -0,0 +1,40 @@
+from dataclasses import dataclass
+
+from canvas_sdk.clients.llms.structures.settings.llm_settings import LlmSettings
+
+
+@dataclass
+class LlmSettingsGpt4(LlmSettings):
+    """Configuration settings for OpenAI GPT-4 LLM API.
+
+    Extends LlmSettings with GPT-4-specific parameters.
+
+    Attributes:
+        api_key: API authentication key for the LLM service (inherited).
+        model: Name or identifier of the LLM model to use (inherited).
+        temperature: Controls randomness in responses (0.0-1.0).
+
+    Example:
+        ```python3
+        LlmSettingsGpt4(
+            api_key=environ.get("openai_key"),
+            model="gpt-4o",
+            temperature=2.0,
+        )
+        ```
+    """
+
+    temperature: float
+
+    def to_dict(self) -> dict:
+        """Convert settings to OpenAI GPT-4 API request format.
+
+        Returns:
+            Dictionary containing model name and temperature.
+        """
+        return super().to_dict() | {
+            "temperature": self.temperature,
+        }
+
+
+__exports__ = ("LlmSettingsGpt4",)

canvas_sdk/clients/llms/structures/settings/llm_settings_gpt5.py

@@ -0,0 +1,48 @@
+from dataclasses import dataclass
+
+from canvas_sdk.clients.llms.structures.settings.llm_settings import LlmSettings
+
+
+@dataclass
+class LlmSettingsGpt5(LlmSettings):
+    """Configuration settings for OpenAI GPT-5 LLM API.
+
+    Extends LlmSettings with GPT-5-specific parameters for reasoning and text generation.
+
+    Attributes:
+        api_key: API authentication key for the LLM service (inherited).
+        model: Name or identifier of the LLM model to use (inherited).
+        reasoning_effort: Level of reasoning effort ('none', 'low', 'medium', 'high').
+        text_verbosity: Level of text verbosity in responses ('low', 'medium', 'high').
+
+    Example:
+        ```python3
+        LlmSettingsGpt5(
+            api_key=environ.get("openai_key"),
+            model="gpt-5.1",
+            reasoning_effort="none",
+            text_verbosity="low",
+        )
+        ```
+    """
+
+    reasoning_effort: str
+    text_verbosity: str
+
+    def to_dict(self) -> dict:
+        """Convert settings to OpenAI GPT-5 API request format.
+
+        Returns:
+            Dictionary containing model name, reasoning config, and text config.
+        """
+        return super().to_dict() | {
+            "reasoning": {
+                "effort": self.reasoning_effort,
+            },
+            "text": {
+                "verbosity": self.text_verbosity,
+            },
+        }
+
+
+__exports__ = ("LlmSettingsGpt5",)

canvas_sdk/clients/third_party.py

@@ -0,0 +1,3 @@
+from stripe import StripeClient
+
+__all__ = __exports__ = ("StripeClient",)

canvas_sdk/commands/__init__.py

@@ -3,6 +3,7 @@ from canvas_sdk.commands.commands.allergy import AllergyCommand
 from canvas_sdk.commands.commands.assess import AssessCommand
 from canvas_sdk.commands.commands.chart_section_review import ChartSectionReviewCommand
 from canvas_sdk.commands.commands.close_goal import CloseGoalCommand
+from canvas_sdk.commands.commands.custom_command import CustomCommand
 from canvas_sdk.commands.commands.diagnose import DiagnoseCommand
 from canvas_sdk.commands.commands.exam import PhysicalExamCommand
 from canvas_sdk.commands.commands.family_history import FamilyHistoryCommand
@@ -28,6 +29,12 @@ from canvas_sdk.commands.commands.refer import ReferCommand
 from canvas_sdk.commands.commands.refill import RefillCommand
 from canvas_sdk.commands.commands.remove_allergy import RemoveAllergyCommand
 from canvas_sdk.commands.commands.resolve_condition import ResolveConditionCommand
+from canvas_sdk.commands.commands.review.imaging import ImagingReviewCommand
+from canvas_sdk.commands.commands.review.lab import LabReviewCommand
+from canvas_sdk.commands.commands.review.referral import ReferralReviewCommand
+from canvas_sdk.commands.commands.review.uncategorized_document import (
+    UncategorizedDocumentReviewCommand,
+)
 from canvas_sdk.commands.commands.review_of_systems import ReviewOfSystemsCommand
 from canvas_sdk.commands.commands.stop_medication import StopMedicationCommand
 from canvas_sdk.commands.commands.structured_assessment import StructuredAssessmentCommand
@@ -47,9 +54,12 @@ __all__ = __exports__ = (
     "FollowUpCommand",
     "GoalCommand",
     "HistoryOfPresentIllnessCommand",
+    "CustomCommand",
     "ImagingOrderCommand",
+    "ImagingReviewCommand",
     "InstructCommand",
     "LabOrderCommand",
+    "LabReviewCommand",
     "MedicalHistoryCommand",
     "MedicationStatementCommand",
     "PastSurgicalHistoryCommand",
@@ -60,6 +70,7 @@ __all__ = __exports__ = (
     "QuestionnaireCommand",
     "ReasonForVisitCommand",
     "ReferCommand",
+    "ReferralReviewCommand",
     "RefillCommand",
     "RemoveAllergyCommand",
     "ResolveConditionCommand",
@@ -67,6 +78,7 @@ __all__ = __exports__ = (
     "StopMedicationCommand",
     "StructuredAssessmentCommand",
     "TaskCommand",
+    "UncategorizedDocumentReviewCommand",
     "UpdateDiagnosisCommand",
     "UpdateGoalCommand",
     "VitalsCommand",

canvas_sdk/commands/base.py

@@ -18,6 +18,7 @@ class _BaseCommand(TrackableFieldsModel):
         originate_required_fields = ("note_uuid",)
         edit_required_fields = ("command_uuid",)
         send_required_fields = ("command_uuid",)
+        review_required_fields = ("command_uuid",)
         delete_required_fields = ("command_uuid",)
         commit_required_fields = ("command_uuid",)
         enter_in_error_required_fields = ("command_uuid",)
@@ -29,11 +30,16 @@ class _BaseCommand(TrackableFieldsModel):
 
     def __init__(self, /, **data: Any) -> None:
         """Initialize the command and mark all provided keys as dirty."""
+        if getattr(self.Meta, "abstract", False):
+            raise TypeError(f"Cannot instantiate abstract class {self.__class__.__name__!r}.")
+
         super().__init__(**data)
 
     def __init_subclass__(cls, **kwargs: Any) -> None:
         """Validate that the command has a key and required fields."""
-        if not hasattr(cls.Meta, "key") or not cls.Meta.key:
+        if (not hasattr(cls.Meta, "key") or not cls.Meta.key) and not getattr(
+            cls.Meta, "abstract", False
+        ):
             raise ImproperlyConfigured(f"Command {cls.__name__!r} must specify Meta.key.")
 
         if hasattr(cls.Meta, "commit_required_fields"):
@@ -118,6 +124,17 @@ class _BaseCommand(TrackableFieldsModel):
             ),
         )
 
+    def _origination_payload_for_batch(self, line_number: int = -1) -> dict:
+        """Originate a new command in the note body for batch processing."""
+        self._validate_before_effect("originate")
+        return {
+            "type": f"ORIGINATE_{self.constantized_key()}_COMMAND",
+            "command": self.command_uuid,
+            "note": self.note_uuid,
+            "data": self.values,
+            "line_number": line_number,
+        }
+
     def edit(self) -> Effect:
         """Edit the command."""
         self._validate_before_effect("edit")
@@ -178,4 +195,18 @@ class _SendableCommandMixin:
         )
 
 
-__exports__ = ("_BaseCommand", "_SendableCommandMixin")
+class _ReviewableCommandMixin:
+    def review(self) -> Effect:
+        """Fire the review effect the command."""
+        self._validate_before_effect("review")  # type: ignore[attr-defined]
+        return Effect(
+            type=f"REVIEW_{self.constantized_key()}_COMMAND",  # type: ignore[attr-defined]
+            payload=json.dumps({"command": self.command_uuid}),  # type: ignore[attr-defined]
+        )
+
+
+__exports__ = (
+    "_BaseCommand",
+    "_SendableCommandMixin",
+    "_ReviewableCommandMixin",
+)

canvas_sdk/commands/commands/adjust_prescription.py

@@ -13,5 +13,9 @@ class AdjustPrescriptionCommand(RefillCommand):
         default=None, json_schema_extra={"commands_api_name": "change_medication_to"}
     )
 
+    def _has_fdb_code(self) -> bool:
+        """Check if new_fdb_code is provided and non-empty."""
+        return self.new_fdb_code is not None and self.new_fdb_code.strip() != ""
+
 
 __exports__ = ("AdjustPrescriptionCommand",)

canvas_sdk/commands/commands/custom_command.py

@@ -0,0 +1,86 @@
+from typing import Any
+
+from pydantic_core import InitErrorDetails
+
+from canvas_sdk.commands.base import _BaseCommand
+
+
+class CustomCommand(_BaseCommand):
+    """A class for managing a custom command within a specific note.
+
+    This class can be extended to create custom commands with predefined schema_key
+    or passing schema_key directly to the constructor.
+    """
+
+    class Meta:
+        key = "customCommand"
+        schema_key: str | None = None
+
+    _schema_key: str | None = None
+    content: str | None = None
+    print_content: str | None = None
+
+    def __init_subclass__(cls, **kwargs: Any) -> None:
+        """Ensure Meta.key is always 'customCommand' for all CustomCommand subclasses."""
+        # Always enforce key = "customCommand" for all subclasses
+        cls.Meta.key = "customCommand"
+
+        # Call parent __init_subclass__ to perform validation
+        super().__init_subclass__(**kwargs)
+
+    def __init__(self, **data: Any) -> None:
+        """Initialize with schema_key from Meta if not provided."""
+        meta_schema_key = getattr(self.__class__.Meta, "schema_key", None)
+
+        # Extract schema_key before init if provided
+        instance_schema_key = data.pop("schema_key", None)
+
+        # If Meta defines schema_key, use it and don't allow override
+        if meta_schema_key is not None and instance_schema_key is not None:
+            raise AttributeError(
+                f"Cannot set schema_key on {self.__class__.__name__} instance. "
+                f"schema_key is already defined in Meta as '{meta_schema_key}'."
+            )
+
+        super().__init__(**data)
+
+        # Set _schema_key after init to ensure it's tracked
+        if meta_schema_key is None and instance_schema_key is not None:
+            self._schema_key = instance_schema_key
+
+    @property
+    def schema_key(self) -> str | None:
+        """Get schema_key from Meta if defined, otherwise from instance attribute."""
+        meta_schema_key = getattr(self.__class__.Meta, "schema_key", None)
+        return meta_schema_key if meta_schema_key is not None else self._schema_key
+
+    @property
+    def values(self) -> dict:
+        """Get values for the custom command."""
+        return {**super().values, "schema_key": self.schema_key}
+
+    def _get_error_details(self, method: str) -> list[InitErrorDetails]:
+        """Get error details for the custom command."""
+        errors = super()._get_error_details(method)
+
+        if method == "originate":
+            if not self.content:
+                errors.append(
+                    self._create_error_detail(
+                        "value",
+                        "Content must be provided for a custom command.",
+                        self.content,
+                    )
+                )
+            if not self.schema_key:
+                errors.append(
+                    self._create_error_detail(
+                        "value",
+                        "Schema key must be provided for a custom command.",
+                        self.schema_key,
+                    )
+                )
+        return errors
+
+
+__exports__ = ("CustomCommand",)

canvas_sdk/commands/commands/family_history.py

@@ -1,4 +1,7 @@
+from pydantic_core import InitErrorDetails
+
 from canvas_sdk.commands.base import _BaseCommand as BaseCommand
+from canvas_sdk.commands.constants import CodeSystems, Coding
 
 
 class FamilyHistoryCommand(BaseCommand):
@@ -7,9 +10,22 @@ class FamilyHistoryCommand(BaseCommand):
     class Meta:
         key = "familyHistory"
 
-    family_history: str | None = None
+    family_history: str | Coding | None = None
     relative: str | None = None
     note: str | None = None
 
+    def _get_error_details(self, method: str) -> list[InitErrorDetails]:
+        errors = super()._get_error_details(method)
+
+        if (
+            isinstance(self.family_history, dict)
+            and self.family_history["system"] != CodeSystems.SNOMED
+            and self.family_history["system"] != CodeSystems.UNSTRUCTURED
+        ):
+            message = f"The 'coding.system' field must be '{CodeSystems.SNOMED}' or '{CodeSystems.UNSTRUCTURED}'."
+            errors.append(self._create_error_detail("value", message, self.family_history))
+
+        return errors
+
 
 __exports__ = ("FamilyHistoryCommand",)

canvas_sdk/commands/commands/immunization_statement.py

@@ -3,6 +3,7 @@ from datetime import date
 from pydantic_core import InitErrorDetails
 
 from canvas_sdk.commands.base import _BaseCommand as BaseCommand
+from canvas_sdk.commands.constants import CodeSystems, Coding
 
 
 class ImmunizationStatementCommand(BaseCommand):
@@ -11,14 +12,53 @@ class ImmunizationStatementCommand(BaseCommand):
     class Meta:
         key = "immunizationStatement"
 
-    cpt_code: str
-    cvx_code: str
+    cpt_code: str | Coding | None = None
+    cvx_code: str | Coding | None = None
+    unstructured: Coding | None = None
     approximate_date: date | None = None
     comments: str | None = None
 
+    def _has_value(self, value: str | Coding | None) -> bool:
+        """Check if a value is set."""
+        if value is None:
+            return False
+        if isinstance(value, str):
+            return value.strip() != ""
+        # For Coding objects (dicts), check if it exists
+        return True
+
     def _get_error_details(self, method: str) -> list[InitErrorDetails]:
         errors = super()._get_error_details(method)
 
+        has_cpt_code = self._has_value(self.cpt_code)
+        has_cvx_code = self._has_value(self.cvx_code)
+
+        if has_cpt_code ^ has_cvx_code:
+            value = self.cpt_code if has_cpt_code else self.cvx_code
+            errors.append(
+                self._create_error_detail(
+                    "value",
+                    "Both cpt_code and cvx_code must be provided if one is specified and cannot be empty.",
+                    value,
+                )
+            )
+
+        if self.unstructured and (has_cpt_code or has_cvx_code):
+            message = "Unstructured codes cannot be used with CPT or CVX codes."
+            errors.append(self._create_error_detail("value", message, self.cpt_code))
+
+        if isinstance(self.cpt_code, dict) and self.cpt_code["system"] != CodeSystems.CPT:
+            message = f"The 'cpt_code.system' field must be '{CodeSystems.CPT}'"
+            errors.append(self._create_error_detail("value", message, self.cpt_code))
+
+        if isinstance(self.cvx_code, dict) and self.cvx_code["system"] != CodeSystems.CVX:
+            message = f"The 'cvx_code.system' field must be '{CodeSystems.CVX}'"
+            errors.append(self._create_error_detail("value", message, self.cvx_code))
+
+        if self.unstructured and self.unstructured["system"] != CodeSystems.UNSTRUCTURED:
+            message = f"The 'unstructured.system' field must be '{CodeSystems.UNSTRUCTURED}'"
+            errors.append(self._create_error_detail("value", message, self.unstructured))
+
         if self.comments and len(self.comments) > 255:
             errors.append(
                 self._create_error_detail(

canvas_sdk/commands/commands/medication_statement.py

@@ -1,6 +1,8 @@
 from pydantic import Field
+from pydantic_core import InitErrorDetails
 
 from canvas_sdk.commands.base import _BaseCommand
+from canvas_sdk.commands.constants import CodeSystems, Coding
 
 
 class MedicationStatementCommand(_BaseCommand):
@@ -9,11 +11,24 @@ class MedicationStatementCommand(_BaseCommand):
     class Meta:
         key = "medicationStatement"
 
-    fdb_code: str | None = Field(
+    fdb_code: str | Coding | None = Field(
         default=None, json_schema_extra={"commands_api_name": "medication"}
     )
     sig: str | None = None
 
+    def _get_error_details(self, method: str) -> list[InitErrorDetails]:
+        errors = super()._get_error_details(method)
+
+        if (
+            isinstance(self.fdb_code, dict)
+            and self.fdb_code["system"] != CodeSystems.FDB
+            and self.fdb_code["system"] != CodeSystems.UNSTRUCTURED
+        ):
+            message = f"The 'coding.system' field must be '{CodeSystems.FDB}' or '{CodeSystems.UNSTRUCTURED}'."
+            errors.append(self._create_error_detail("value", message, self.fdb_code))
+
+        return errors
+
 
 # how do we make sure fdb_code is a valid code?
 

canvas_sdk/commands/commands/past_surgical_history.py

@@ -1,8 +1,10 @@
 from datetime import date
 
 from pydantic import Field
+from pydantic_core import InitErrorDetails
 
 from canvas_sdk.commands.base import _BaseCommand as BaseCommand
+from canvas_sdk.commands.constants import CodeSystems, Coding
 
 
 class PastSurgicalHistoryCommand(BaseCommand):
@@ -11,9 +13,22 @@ class PastSurgicalHistoryCommand(BaseCommand):
     class Meta:
         key = "surgicalHistory"
 
-    past_surgical_history: str | None = None
+    past_surgical_history: str | Coding | None = None
     approximate_date: date | None = None
     comment: str | None = Field(max_length=1000, default=None)
 
+    def _get_error_details(self, method: str) -> list[InitErrorDetails]:
+        errors = super()._get_error_details(method)
+
+        if (
+            isinstance(self.past_surgical_history, dict)
+            and self.past_surgical_history["system"] != CodeSystems.SNOMED
+            and self.past_surgical_history["system"] != CodeSystems.UNSTRUCTURED
+        ):
+            message = f"The 'coding.system' field must be '{CodeSystems.SNOMED}' or '{CodeSystems.UNSTRUCTURED}'."
+            errors.append(self._create_error_detail("value", message, self.past_surgical_history))
+
+        return errors
+
 
 __exports__ = ("PastSurgicalHistoryCommand",)

canvas_sdk/commands/commands/perform.py

@@ -1,6 +1,8 @@
 from pydantic import Field
+from pydantic_core import InitErrorDetails
 
 from canvas_sdk.commands.base import _BaseCommand as BaseCommand
+from canvas_sdk.commands.constants import CodeSystems, Coding
 
 
 class PerformCommand(BaseCommand):
@@ -9,8 +11,23 @@ class PerformCommand(BaseCommand):
     class Meta:
         key = "perform"
 
-    cpt_code: str | None = Field(default=None, json_schema_extra={"commands_api_name": "perform"})
+    cpt_code: str | Coding | None = Field(
+        default=None, json_schema_extra={"commands_api_name": "perform"}
+    )
     notes: str | None = None
 
+    def _get_error_details(self, method: str) -> list[InitErrorDetails]:
+        errors = super()._get_error_details(method)
+
+        if (
+            isinstance(self.cpt_code, dict)
+            and self.cpt_code["system"] != CodeSystems.CPT
+            and self.cpt_code["system"] != CodeSystems.UNSTRUCTURED
+        ):
+            message = f"The 'coding.system' field must be '{CodeSystems.CPT}' or '{CodeSystems.UNSTRUCTURED}'."
+            errors.append(self._create_error_detail("value", message, self.cpt_code))
+
+        return errors
+
 
 __exports__ = ("PerformCommand",)

canvas_sdk/commands/commands/prescribe.py

@@ -7,7 +7,7 @@ from typing import Any
 from pydantic import Field, conlist
 from pydantic_core import InitErrorDetails
 
-from canvas_sdk.commands.base import _BaseCommand, _SendableCommandMixin
+from canvas_sdk.commands.base import _BaseCommand, _ReviewableCommandMixin, _SendableCommandMixin
 from canvas_sdk.commands.constants import ClinicalQuantity
 from canvas_sdk.effects import Effect
 from canvas_sdk.effects.compound_medications.compound_medication import (
@@ -37,7 +37,7 @@ class CompoundMedicationData:
         }
 
 
-class PrescribeCommand(_SendableCommandMixin, _BaseCommand):
+class PrescribeCommand(_ReviewableCommandMixin, _SendableCommandMixin, _BaseCommand):
     """A class for managing a Prescribe command within a specific note."""
 
     class Meta:
@@ -74,12 +74,16 @@ class PrescribeCommand(_SendableCommandMixin, _BaseCommand):
         default=None, json_schema_extra={"commands_api_name": "compound_medication_data"}
     )
 
+    def _has_fdb_code(self) -> bool:
+        """Check if fdb_code is provided and non-empty."""
+        return self.fdb_code is not None and self.fdb_code.strip() != ""
+
     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_fdb_code = self._has_fdb_code()
         has_compound_medication_id = (
             self.compound_medication_id is not None and self.compound_medication_id.strip() != ""
         )
@@ -156,10 +160,8 @@ class PrescribeCommand(_SendableCommandMixin, _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")
+            values["compound_medication_values"] = {"id": values.pop("compound_medication_id")}
 
         # Handle compound medication data
         elif (
@@ -170,9 +172,6 @@ class PrescribeCommand(_SendableCommandMixin, _BaseCommand):
             if isinstance(compound_data, CompoundMedicationData):
                 values["compound_medication_values"] = compound_data.to_dict()
 
-        if values.get("fdb_code") is not None and values.get("compound_medication_values") == {}:
-            del values["compound_medication_values"]
-
         return values
 
     def originate(self, line_number: int = -1) -> Effect:

canvas_sdk/commands/commands/refill.py

@@ -1,4 +1,4 @@
-from typing import Literal
+from typing import cast
 
 from django.db.models.expressions import Subquery
 from pydantic_core import InitErrorDetails
@@ -13,13 +13,13 @@ class RefillCommand(PrescribeCommand):
     class Meta:
         key = "refill"
 
-    def _get_error_details(
-        self, method: Literal["originate", "edit", "delete", "commit", "enter_in_error"]
-    ) -> list[InitErrorDetails]:
+    def _get_error_details(self, method: str) -> list[InitErrorDetails]:
         errors = super()._get_error_details(method)
 
         if self.fdb_code:
-            subquery = Subquery(Note.objects.filter(id=self.note_uuid).values("patient_id")[:1])
+            subquery = Subquery(
+                Note.objects.filter(id=cast(str, self.note_uuid)).values("patient_id")[:1]
+            )
             if (
                 not Medication.objects.active()
                 .filter(codings__code=self.fdb_code, patient=subquery)

canvas_sdk/commands/commands/resolve_condition.py

@@ -1,4 +1,4 @@
-from typing import Literal
+from typing import cast
 from uuid import UUID
 
 from django.db.models.expressions import Subquery
@@ -21,13 +21,13 @@ class ResolveConditionCommand(BaseCommand):
     show_in_condition_list: bool = False
     rationale: str | None = Field(max_length=1024, default=None)
 
-    def _get_error_details(
-        self, method: Literal["originate", "edit", "delete", "commit", "enter_in_error"]
-    ) -> list[InitErrorDetails]:
+    def _get_error_details(self, method: str) -> list[InitErrorDetails]:
         errors = super()._get_error_details(method)
 
         if self.condition_id:
-            subquery = Subquery(Note.objects.filter(id=self.note_uuid).values("patient_id")[:1])
+            subquery = Subquery(
+                Note.objects.filter(id=cast(str, self.note_uuid)).values("patient_id")[:1]
+            )
             if (
                 not Condition.objects.active()
                 .filter(id=self.condition_id, patient=subquery)

canvas_sdk/commands/commands/review/__init__.py

@@ -0,0 +1,3 @@
+from canvas_sdk.commands.commands.review.base import ReportReviewCommunicationMethod, ReviewMode
+
+__all__ = __exports__ = ("ReportReviewCommunicationMethod", "ReviewMode")