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

canvas_sdk/test_utils/factories/lab.py

@@ -0,0 +1,192 @@
+from typing import Any
+
+import factory
+from django.utils import timezone
+
+from canvas_sdk.v1.data import (
+    LabOrder,
+    LabOrderReason,
+    LabOrderReasonCondition,
+    LabPartner,
+    LabPartnerTest,
+    LabReport,
+    LabReview,
+    LabTest,
+    LabValue,
+    LabValueCoding,
+)
+from canvas_sdk.v1.data.common import (
+    DocumentReviewMode,
+    ReviewPatientCommunicationMethod,
+    ReviewStatus,
+)
+from canvas_sdk.v1.data.lab import TransmissionType
+
+
+class LabReportFactory(factory.django.DjangoModelFactory[LabReport]):
+    """Factory for creating a LabReport."""
+
+    class Meta:
+        model = LabReport
+
+    review_mode = DocumentReviewMode.REVIEW_REQUIRED
+    junked = False
+    requires_signature = False
+    assigned_date = factory.LazyFunction(lambda: timezone.now())
+    patient = factory.SubFactory("canvas_sdk.test_utils.factories.PatientFactory")
+    transmission_type = TransmissionType.HL7
+    for_test_only = False
+    external_id = factory.Faker("uuid4")
+    version = 1
+    requisition_number = factory.Faker("bothify", text="REQ-########")
+    review = None  # Optional field
+    original_date = factory.LazyFunction(lambda: timezone.now())
+    date_performed = factory.LazyFunction(lambda: timezone.now())
+    custom_document_name = factory.Faker("text", max_nb_chars=500)
+
+
+class LabReviewFactory(factory.django.DjangoModelFactory[LabReview]):
+    """Factory for creating a LabReview."""
+
+    class Meta:
+        model = LabReview
+
+    internal_comment = factory.Faker("paragraph")
+    message_to_patient = factory.Faker("text", max_nb_chars=2048)
+    status = ReviewStatus.STATUS_REVIEWING
+    patient = factory.SubFactory("canvas_sdk.test_utils.factories.PatientFactory")
+    patient_communication_method = ReviewPatientCommunicationMethod.DELEGATED_CALL_CAN_LEAVE_MESSAGE
+
+
+class LabValueFactory(factory.django.DjangoModelFactory[LabValue]):
+    """Factory for creating a LabValue."""
+
+    class Meta:
+        model = LabValue
+
+    report = factory.SubFactory(LabReportFactory)
+    value = factory.Faker("bothify", text="##.#")
+    units = factory.Faker("random_element", elements=["mg/dL", "mmol/L", "g/dL", "%", "U/L"])
+    abnormal_flag = factory.Faker("random_element", elements=["", "H", "L", "HH", "LL"])
+    reference_range = factory.Faker("bothify", text="#.#-##.#")
+    low_threshold = factory.Faker("bothify", text="#.#")
+    high_threshold = factory.Faker("bothify", text="##.#")
+    comment = factory.Faker("sentence")
+    observation_status = factory.Faker(
+        "random_element", elements=["final", "preliminary", "corrected"]
+    )
+
+
+class LabValueCodingFactory(factory.django.DjangoModelFactory[LabValueCoding]):
+    """Factory for creating a LabValueCoding."""
+
+    class Meta:
+        model = LabValueCoding
+
+    value = factory.SubFactory(LabValueFactory)
+    code = factory.Faker("bothify", text="#####-#")
+    name = factory.Faker("text", max_nb_chars=256)
+    system = factory.Faker("random_element", elements=["LOINC", "SNOMED", "CPT"])
+
+
+class LabOrderFactory(factory.django.DjangoModelFactory[LabOrder]):
+    """Factory for creating a LabOrder."""
+
+    class Meta:
+        model = LabOrder
+        skip_postgeneration_save = True
+
+    patient = factory.SubFactory("canvas_sdk.test_utils.factories.PatientFactory")
+    ontology_lab_partner = factory.Faker("company")
+    note = factory.SubFactory("canvas_sdk.test_utils.factories.NoteFactory")
+    comment = factory.Faker("text", max_nb_chars=128)
+    requisition_number = factory.Faker("bothify", text="REQ-########")
+    is_patient_bill = False
+    date_ordered = factory.LazyFunction(lambda: timezone.now())
+    fasting_status = None  # Optional field
+    specimen_collection_type = LabOrder.SpecimenCollectionType.ON_LOCATION
+    transmission_type = TransmissionType.HL7
+    courtesy_copy_type = None  # Optional field
+    courtesy_copy_number = ""
+    courtesy_copy_text = ""
+    ordering_provider = factory.SubFactory("canvas_sdk.test_utils.factories.StaffFactory")
+    parent_order = None  # Optional field
+    healthgorilla_id = ""
+    manual_processing_status = None  # Optional field
+    manual_processing_comment = None  # Optional field
+    labcorp_abn_url = ""
+
+    @factory.post_generation
+    def reports(self, create: Any, extracted: Any, **kwargs: Any) -> None:
+        """Handle many-to-many relationship for reports."""
+        if not create:
+            return
+
+        if extracted:
+            for report in extracted:
+                self.reports.add(report)
+
+
+class LabOrderReasonFactory(factory.django.DjangoModelFactory[LabOrderReason]):
+    """Factory for creating a LabOrderReason."""
+
+    class Meta:
+        model = LabOrderReason
+
+    order = factory.SubFactory(LabOrderFactory)
+    mode = LabOrderReason.LabReasonMode.MONITOR
+
+
+class LabOrderReasonConditionFactory(factory.django.DjangoModelFactory[LabOrderReasonCondition]):
+    """Factory for creating a LabOrderReasonCondition."""
+
+    class Meta:
+        model = LabOrderReasonCondition
+
+    reason = factory.SubFactory(LabOrderReasonFactory)
+    condition = None  # Optional field - would need a ConditionFactory
+
+
+class LabTestFactory(factory.django.DjangoModelFactory[LabTest]):
+    """Factory for creating a LabTest."""
+
+    class Meta:
+        model = LabTest
+
+    ontology_test_name = factory.Faker("text", max_nb_chars=512)
+    ontology_test_code = factory.Faker("bothify", text="####-#")
+    status = LabTest.LabTestOrderStatus.NEW
+    report = factory.SubFactory(LabReportFactory)
+    aoe_code = ""
+    procedure_class = ""
+    specimen_type = factory.Faker("random_element", elements=["blood", "urine", "serum", "plasma"])
+    specimen_source_code = factory.Faker("bothify", text="###")
+    specimen_source_description = factory.Faker("text", max_nb_chars=255)
+    specimen_source_coding_system = factory.Faker("random_element", elements=["LOINC", "SNOMED"])
+    order = factory.SubFactory(LabOrderFactory)
+
+
+class LabPartnerFactory(factory.django.DjangoModelFactory[LabPartner]):
+    """Factory for creating a LabPartner."""
+
+    class Meta:
+        model = LabPartner
+
+    name = factory.Faker("company")
+    active = True
+    electronic_ordering_enabled = True
+    keywords = factory.Faker("words", nb=5)
+    default_lab_account_number = factory.Faker("bothify", text="LAB-######")
+
+
+class LabPartnerTestFactory(factory.django.DjangoModelFactory[LabPartnerTest]):
+    """Factory for creating a LabPartnerTest."""
+
+    class Meta:
+        model = LabPartnerTest
+
+    lab_partner = factory.SubFactory(LabPartnerFactory)
+    order_code = factory.Faker("bothify", text="####")
+    order_name = factory.Faker("text", max_nb_chars=256)
+    keywords = factory.Faker("words", nb=5)
+    cpt_code = factory.Faker("bothify", text="#####")

canvas_sdk/test_utils/factories/medication_history.py

@@ -0,0 +1,75 @@
+import datetime
+
+import factory
+from django.utils import timezone
+from factory.fuzzy import FuzzyDate, FuzzyDateTime
+
+from canvas_sdk.test_utils.factories.patient import PatientFactory
+from canvas_sdk.v1.data.medication_history import (
+    MedicationHistoryMedication,
+    MedicationHistoryMedicationCoding,
+    MedicationHistoryResponse,
+    MedicationHistoryResponseStatus,
+)
+
+
+class MedicationHistoryMedicationFactory(
+    factory.django.DjangoModelFactory[MedicationHistoryMedication]
+):
+    """Factory for creating a MedicationHistoryMedication."""
+
+    class Meta:
+        model = MedicationHistoryMedication
+
+    patient = factory.SubFactory(PatientFactory)
+    last_fill_date = FuzzyDateTime(
+        start_dt=timezone.now() - datetime.timedelta(days=365), end_dt=timezone.now()
+    )
+
+    drug_description = factory.Faker("word")
+    strength_value = "10"
+    strength_form = "tablet"
+    strength_unit_of_measure = "mg"
+    quantity = 30.0
+    quantity_unit_of_measure = "tablets"
+    days_supply = 30
+    sig = factory.Faker("sentence", nb_words=4)
+
+
+class MedicationHistoryMedicationCodingFactory(
+    factory.django.DjangoModelFactory[MedicationHistoryMedicationCoding]
+):
+    """Factory for creating a MedicationHistoryMedicationCoding."""
+
+    class Meta:
+        model = MedicationHistoryMedicationCoding
+
+    medication = factory.SubFactory(MedicationHistoryMedicationFactory)
+
+    system = "http://www.nlm.nih.gov/research/umls/rxnorm"
+    version = "1.0"
+    code = factory.Faker("numerify", text="######")
+    display = factory.Faker("word")
+    user_selected = False
+
+
+class MedicationHistoryResponseFactory(
+    factory.django.DjangoModelFactory[MedicationHistoryResponse]
+):
+    """Factory for creating a MedicationHistoryResponse."""
+
+    class Meta:
+        model = MedicationHistoryResponse
+
+    patient = factory.SubFactory(PatientFactory)
+    status = MedicationHistoryResponseStatus.STATUS_APPROVED
+    start_date = FuzzyDate(
+        start_date=datetime.date.today() - datetime.timedelta(days=365),
+        end_date=datetime.date.today(),
+    )
+    end_date = FuzzyDate(
+        start_date=datetime.date.today(),
+        end_date=datetime.date.today() + datetime.timedelta(days=365),
+    )
+    message_id = factory.Faker("uuid4")
+    related_to_message_id = factory.Faker("uuid4")

canvas_sdk/test_utils/factories/note.py

@@ -0,0 +1,52 @@
+from typing import Any
+
+import factory
+
+from canvas_sdk.v1.data import Note, NoteStateChangeEvent, NoteType
+from canvas_sdk.v1.data.note import NoteStates
+
+
+class NoteFactory(factory.django.DjangoModelFactory[Note]):
+    """Factory for creating Note."""
+
+    class Meta:
+        model = Note
+
+    location = factory.SubFactory("canvas_sdk.test_utils.factories.PracticeLocationFactory")
+    originator = factory.SelfAttribute("provider.user")
+    provider = factory.SubFactory("canvas_sdk.test_utils.factories.StaffFactory")
+    patient = factory.SubFactory("canvas_sdk.test_utils.factories.PatientFactory")
+    note_type_version = factory.SubFactory("canvas_sdk.test_utils.factories.NoteTypeFactory")
+
+    @factory.post_generation
+    def create_initial_state_change_event(self, create: Any, extracted: Any, **kwargs: Any) -> None:
+        """Create an initial NoteStateChangeEvent when a Note is created."""
+        if not create:
+            return
+
+        NoteStateChangeEventFactory.create(note=self, state=NoteStates.NEW)
+
+
+class NoteStateChangeEventFactory(factory.django.DjangoModelFactory[NoteStateChangeEvent]):
+    """Factory for creating NoteStateChangeEvent."""
+
+    class Meta:
+        model = NoteStateChangeEvent
+
+    note = factory.SubFactory(NoteFactory)
+    state = NoteStates.NEW
+    originator = factory.SelfAttribute("note.originator")
+
+
+class NoteTypeFactory(factory.django.DjangoModelFactory[NoteType]):
+    """Factory for creating NoteType."""
+
+    class Meta:
+        model = NoteType
+
+    available_places_of_service = ["01"]
+    name = factory.Faker("sentence", nb_words=1)
+    code = factory.Faker("sentence", nb_words=1)
+    system = factory.Faker("sentence", nb_words=1)
+    icon = factory.Faker("sentence", nb_words=1)
+    display = factory.Faker("sentence", nb_words=1)

canvas_sdk/test_utils/factories/organization.py

@@ -0,0 +1,50 @@
+import factory
+
+from canvas_sdk.v1.data import Organization, OrganizationAddress, OrganizationContactPoint
+from canvas_sdk.v1.data.common import ContactPointSystem, ContactPointUse
+
+
+class OrganizationFactory(factory.django.DjangoModelFactory[Organization]):
+    """Factory for creating Organization."""
+
+    class Meta:
+        model = Organization
+
+    short_name = "Canvas Medical"
+    full_name = "Canvas Medical, Inc."
+    logo_url = "https://s3-us-west-2.amazonaws.com/canvas-pcp-assets/canvas_logo_large.png"
+    background_image_url = "https://s3-us-west-2.amazonaws.com/canvas-pcp-assets/santa-cruz-low.jpg"
+    background_gradient = (
+        "linear-gradient(to top, rgb(231, 201, 154) 0%, rgb(220, 210, 192) 29%, "
+        "rgb(156, 175, 191) 90%, rgb(147, 166, 189) 100%)"
+    )
+    tax_id = "123456"
+
+
+class OrganizationAddressFactory(factory.django.DjangoModelFactory[OrganizationAddress]):
+    """Factory for creating OrganizationAddress."""
+
+    class Meta:
+        model = OrganizationAddress
+
+    organization = factory.SubFactory(OrganizationFactory)
+    line1 = "456 Organization Ave"
+    line2 = "#2"
+    city = "San Francisco"
+    district = "Sunset"
+    state_code = "CA"
+    postal_code = "94112"
+    country = "USA"
+
+
+class OrganizationContactPointFactory(factory.django.DjangoModelFactory[OrganizationContactPoint]):
+    """Factory for creating OrganizationContactPoint."""
+
+    class Meta:
+        model = OrganizationContactPoint
+
+    organization = factory.SubFactory(OrganizationFactory)
+    system = ContactPointSystem.PHONE
+    value = "8003701416"
+    use = ContactPointUse.WORK
+    rank = 1

canvas_sdk/test_utils/factories/practicelocation.py

@@ -0,0 +1,88 @@
+from datetime import date
+
+import factory
+
+from canvas_sdk.v1.data import (
+    PracticeLocation,
+    PracticeLocationAddress,
+    PracticeLocationContactPoint,
+    PracticeLocationSetting,
+)
+from canvas_sdk.v1.data.common import (
+    AddressState,
+    AddressType,
+    AddressUse,
+    ContactPointSystem,
+    ContactPointUse,
+)
+
+
+class PracticeLocationSettingFactory(factory.django.DjangoModelFactory[PracticeLocationSetting]):
+    """Factory for PracticeLocationSetting."""
+
+    class Meta:
+        model = PracticeLocationSetting
+        django_get_or_create = ("name",)
+
+    name = factory.Sequence(lambda n: f"location_setting_{n}")
+    value = {"random": "json"}
+
+
+class PracticeLocationFactory(factory.django.DjangoModelFactory[PracticeLocation]):
+    """Factory for PracticeLocation."""
+
+    class Meta:
+        model = PracticeLocation
+
+    organization = factory.SubFactory(
+        "canvas_sdk.test_utils.factories.organization.OrganizationFactory"
+    )
+    short_name = "Family Doctors of SF"
+    full_name = "Family Doctors of San Francisco"
+    setting = factory.RelatedFactory(PracticeLocationSettingFactory, "practice_location")
+    bill_through_organization = True
+    billing_location_name = "Billing Location Name"
+    tax_id = "123456789"
+    tax_id_type = "E"
+    npi_number = "1234567890"
+    group_npi_number = "112233445"
+
+
+class PracticeLocationAddressFactory(factory.django.DjangoModelFactory[PracticeLocationAddress]):
+    """Factory for PracticeLocationAddress."""
+
+    class Meta:
+        model = PracticeLocationAddress
+
+    practice_location = factory.SubFactory(
+        "canvas_sdk.test_utils.factories.PracticeLocationFactory"
+    )
+    line1 = "1234 Golden Gate Ave."
+    line2 = "Suite 456"
+    city = "San Francisco"
+    district = ""
+    state_code = "CA"
+    postal_code = "94100"
+    use = AddressUse.WORK
+    type = AddressType.BOTH
+    longitude = -122.476944
+    latitude = 37.769722
+    start = date(year=2015, month=10, day=10)
+    end = None
+    country = "USA"
+    state = AddressState.ACTIVE
+
+
+class PracticeLocationContactPointFactory(
+    factory.django.DjangoModelFactory[PracticeLocationContactPoint]
+):
+    """Factory for creating PracticeLocationContactPoint."""
+
+    class Meta:
+        model = PracticeLocationContactPoint
+
+    practice_location = factory.SubFactory(PracticeLocationFactory)
+    system = ContactPointSystem.PHONE
+    value = "8003701416"
+    use = ContactPointUse.WORK
+    rank = 1

canvas_sdk/test_utils/factories/referral.py

@@ -0,0 +1,81 @@
+import datetime
+import json
+from typing import Any
+
+import factory
+from django.utils import timezone
+from factory.fuzzy import FuzzyDate
+
+from canvas_sdk.v1.data import Referral, ReferralReport, ReferralReview
+
+
+class ReferralFactory(factory.django.DjangoModelFactory[Referral]):
+    """Factory for creating a Referral."""
+
+    class Meta:
+        model = Referral
+
+    patient = factory.SubFactory("canvas_sdk.test_utils.factories.PatientFactory")
+    note = factory.SubFactory("canvas_sdk.test_utils.factories.NoteFactory")
+    service_provider = None  # Optional field
+    clinical_question = factory.Faker("text", max_nb_chars=50)
+    priority = factory.Faker("random_element", elements=["routine", "urgent", "stat"])
+    include_visit_note = False
+    notes = factory.Faker("paragraph")
+    date_referred = factory.LazyFunction(lambda: timezone.now())
+    forwarded = False
+    internal_comment = factory.Faker("paragraph")
+    internal_task_comment = None  # Optional field
+    ignored = False
+    task_ids = factory.LazyFunction(lambda: json.dumps([]))
+
+    @factory.post_generation
+    def assessments(self, create: Any, extracted: Any, **kwargs: Any) -> None:
+        """Handle many-to-many relationship for assessments."""
+        if not create:
+            return
+
+        if extracted:
+            for assessment in extracted:
+                self.assessments.add(assessment)
+
+
+class ReferralReviewFactory(factory.django.DjangoModelFactory[ReferralReview]):
+    """Factory for creating a ReferralReview."""
+
+    class Meta:
+        model = ReferralReview
+
+    internal_comment = factory.Faker("paragraph")
+    message_to_patient = factory.Faker("sentence", nb_words=20)
+    status = factory.Faker("random_element", elements=["pending", "reviewed", "completed"])
+    patient = factory.SubFactory("canvas_sdk.test_utils.factories.PatientFactory")
+    patient_communication_method = factory.Faker(
+        "random_element", elements=["email", "phone", "portal", "mail"]
+    )
+
+
+class ReferralReportFactory(factory.django.DjangoModelFactory[ReferralReport]):
+    """Factory for creating a ReferralReport."""
+
+    class Meta:
+        model = ReferralReport
+
+    originator = factory.SubFactory("canvas_sdk.test_utils.factories.CanvasUserFactory")
+    review_mode = factory.Faker("random_element", elements=["IN", "OT"])
+    assigned_by = factory.SubFactory("canvas_sdk.test_utils.factories.CanvasUserFactory")
+    junked = False
+    requires_signature = factory.Faker("boolean")
+    assigned_date = factory.LazyFunction(lambda: timezone.now())
+    team_assigned_date = None
+    team = None
+    patient = factory.SubFactory("canvas_sdk.test_utils.factories.PatientFactory")
+    referral = factory.SubFactory(ReferralFactory)
+    specialty = factory.Faker("job")
+    review = None
+    original_date = FuzzyDate(
+        start_date=datetime.date.today() - datetime.timedelta(days=365),
+        end_date=datetime.date.today(),
+    )
+    comment = factory.Faker("paragraph")
+    priority = False

canvas_sdk/test_utils/factories/staff.py

@@ -0,0 +1,111 @@
+import datetime
+
+import factory
+from dateutil.relativedelta import relativedelta
+
+from canvas_sdk.v1.data import (
+    Staff,
+    StaffAddress,
+    StaffContactPoint,
+    StaffLicense,
+    StaffPhoto,
+    StaffRole,
+)
+from canvas_sdk.v1.data.common import ContactPointSystem, ContactPointUse
+
+
+class StaffAddressFactory(factory.django.DjangoModelFactory[StaffAddress]):
+    """Factory for creating StaffAddress."""
+
+    class Meta:
+        model = StaffAddress
+
+    line1 = "1234 Main Street"
+    line2 = "Apt 3"
+    city = "San Francisco"
+    district = "Sunset"
+    state_code = "CA"
+    postal_code = "94112"
+    country = "USA"
+    staff = factory.SubFactory("canvas_sdk.test_utils.factories.StaffFactory")
+
+
+class StaffPhotoFactory(factory.django.DjangoModelFactory[StaffPhoto]):
+    """Factory for creating StaffPhoto."""
+
+    class Meta:
+        model = StaffPhoto
+
+    url = ""
+    staff = factory.SubFactory("canvas_sdk.test_utils.factories.StaffFactory")
+
+
+class StaffRoleFactory(factory.django.DjangoModelFactory[StaffRole]):
+    """Factory for creating StaffRole."""
+
+    class Meta:
+        model = StaffRole
+        django_get_or_create = ("internal_code", "staff")
+
+    internal_code = "MD"
+    name = "Physician"
+    public_abbreviation = "MD"
+    domain = StaffRole.RoleDomain.CLINICAL
+    domain_privilege_level = 100000
+    permissions = factory.LazyFunction(lambda: {})
+    staff = factory.SubFactory("canvas_sdk.test_utils.factories.StaffFactory")
+
+
+class StaffLicenseFactory(factory.django.DjangoModelFactory[StaffLicense]):
+    """Factory for creating StaffLicense."""
+
+    class Meta:
+        model = StaffLicense
+
+    issuing_authority_long_name = "MEDICAL BOARD OF CALIFORNIA"
+    issuing_authority_url = "http://www.mbc.ca.gov/"
+    license_or_certification_identifier = "A60695"
+    issuance_date = factory.LazyFunction(datetime.date.today)
+    expiration_date = factory.LazyFunction(lambda: datetime.date.today() + relativedelta(years=2))
+    staff = factory.SubFactory("canvas_sdk.test_utils.factories.StaffFactory")
+
+
+class StaffContactPointFactory(factory.django.DjangoModelFactory[StaffContactPoint]):
+    """Factory for creating StaffContactPoint."""
+
+    class Meta:
+        model = StaffContactPoint
+
+    value = "8883331212"
+    system = ContactPointSystem.PHONE
+    use = ContactPointUse.HOME
+    staff = factory.SubFactory("canvas_sdk.test_utils.factories.StaffFactory")
+
+
+class StaffFactory(factory.django.DjangoModelFactory[Staff]):
+    """Factory for creating Staff."""
+
+    class Meta:
+        model = Staff
+        django_get_or_create = ("user",)
+
+    first_name = factory.Faker("first_name")
+    middle_name = factory.Faker("first_name")
+    last_name = factory.Faker("last_name")
+    npi_number = "1111155556"
+    group_npi_number = "123456789"
+    tax_id = "98711111"
+    spi_number = 5630156655001
+    address = factory.RelatedFactory(StaffAddressFactory, "staff")
+    telecom = factory.RelatedFactory(StaffContactPointFactory, "staff")
+    primary_practice_location = factory.SubFactory(
+        "canvas_sdk.test_utils.factories.PracticeLocationFactory"
+    )
+    photos = factory.RelatedFactory(StaffPhotoFactory, "staff")
+    role = factory.RelatedFactory(StaffRoleFactory, "staff")
+    license = factory.RelatedFactory(StaffLicenseFactory, "staff")
+    birth_date = factory.Faker("date_object")
+
+    user = factory.SubFactory(
+        "canvas_sdk.test_utils.factories.user.CanvasUserFactory",
+    )