endoreg-db 0.8.9.32__py3-none-any.whl

endoreg_db/models/medical/patient/patient_lab_sample.py

@@ -0,0 +1,157 @@
+from datetime import datetime as dt
+from datetime import timezone
+from typing import TYPE_CHECKING
+
+from django.db import models
+
+if TYPE_CHECKING:
+    from endoreg_db.models import LabValue, Patient, PatientLabValue
+    from endoreg_db.utils.links.requirement_link import RequirementLinks  # Added import
+
+DEFAULT_PATIENT_LAB_SAMPLE_TYPE_NAME = "generic"
+
+
+class PatientLabSampleTypeManager(models.Manager):
+    """Manager for PatientLabSampleType with natural key support."""
+
+    def get_by_natural_key(self, name):
+        """Retrieves a PatientLabSampleType instance by its natural key (name)."""
+        return self.get(name=name)
+
+
+class PatientLabSampleType(models.Model):
+    """
+    Represents the type of a patient lab sample (e.g., Blood, Urine).
+
+    Attributes:
+        name (str): The name of the patient lab sample type.
+        description (str): A description of the patient lab sample type.
+    """
+
+    name = models.CharField(max_length=255)
+    description = models.TextField(blank=True, null=True)
+
+    objects = PatientLabSampleTypeManager()
+
+    def natural_key(self):
+        """Returns the natural key (name) as a tuple."""
+        return (self.name,)
+
+    def __str__(self):
+        """Returns the name of the sample type."""
+        return str(self.name)
+
+    @classmethod
+    def get_default_sample_type(cls):
+        """Gets or creates the default patient lab sample type ('default')."""
+        return cls.objects.get_or_create(name="default")[0]
+
+
+class PatientLabSample(models.Model):
+    """
+    Represents a specific lab sample taken from a patient at a certain date and time.
+
+    Links to the patient, sample type, and associated lab values.
+
+    Attributes:
+        patient (Patient): The patient to which the lab sample belongs.
+        sample_type (PatientLabSampleType): The type of the lab sample.
+        date (datetime): The date of the lab sample.
+        values (PatientLabValue; One2Many): The value of the lab sample.
+    """
+
+    patient = models.ForeignKey(
+        "Patient", on_delete=models.CASCADE, related_name="lab_samples"
+    )
+    sample_type = models.ForeignKey("PatientLabSampleType", on_delete=models.CASCADE)
+    date = models.DateTimeField()
+
+    if TYPE_CHECKING:
+        patient: models.ForeignKey["Patient"]
+        sample_type: models.ForeignKey["PatientLabSampleType"]
+
+        @property
+        def values(self) -> models.manager.RelatedManager["PatientLabValue"]: ...
+
+    def __str__(self):
+        """Returns a string representation including patient, type, and date."""
+        formatted_datetime = self.date.strftime("%Y-%m-%d %H:%M")
+        return f"{self.patient} - {self.sample_type} - {formatted_datetime} ()"
+
+    def get_values(self):
+        """Returns all PatientLabValue instances associated with this sample."""
+        return self.values.all()
+
+    @property
+    def links(self) -> "RequirementLinks":
+        """
+        Aggregates and returns all related model instances relevant for requirement evaluation
+        as a RequirementLinks object.
+        """
+        from endoreg_db.utils.links.requirement_link import RequirementLinks
+        # Assuming PatientLabValue is already imported or accessible
+        # from .patient_lab_value import PatientLabValue # If direct import needed and not circular
+
+        patient_lab_values = list(self.values.all())
+
+        return RequirementLinks(
+            patient_lab_values=patient_lab_values,
+            patient_lab_samples=[self],  # Include the sample itself
+        )
+
+    @classmethod
+    def create_by_patient(cls, patient=None, sample_type=None, date=None, save=True):
+        """
+        Creates a new patient lab sample for a given patient.
+
+        Uses default type and current time if not provided.
+
+        Args:
+            patient (Patient): The patient to which the lab sample belongs.
+            sample_type (PatientLabSampleType): The type of the lab sample.
+            date (datetime): The date of the lab sample.
+            save (bool): Whether to save the instance after creation.
+
+        Returns:
+            PatientLabSample: The new patient lab sample.
+        """
+        from warnings import warn
+
+        if not patient:
+            warn("No patient given. Cannot create patient lab sample.")
+            return None
+        if not sample_type:
+            sample_type = PatientLabSampleType.get_default_sample_type()
+        else:
+            sample_type = PatientLabSampleType.objects.get(name=sample_type)
+        if not date:
+            date = dt.now(timezone.utc)
+
+        patient_lab_sample = cls.objects.create(
+            patient=patient, sample_type=sample_type, date=date
+        )
+
+        if save:
+            patient_lab_sample.save()
+
+        return patient_lab_sample
+
+    def add_empty_value(self, lab_value: "LabValue"):
+        """
+        Adds an empty PatientLabValue for the given lab value to this sample.
+
+        Args:
+            lab_value (LabValue): The lab value to add.
+        """
+        from endoreg_db.models import LabValue, PatientLabValue
+
+        if not isinstance(lab_value, LabValue):
+            raise ValueError("lab_value must be an instance of LabValue.")
+        patient_lab_value = PatientLabValue.create_lab_value_by_sample(
+            sample=self,
+            lab_value_name=lab_value.name,
+            value=None,  # Empty value
+            value_str=None,  # Empty string
+            unit=lab_value.default_unit,  # Use the unit from the lab value
+        )
+        return patient_lab_value

endoreg_db/models/medical/patient/patient_lab_value.py

@@ -0,0 +1,247 @@
+import numbers
+from typing import TYPE_CHECKING, Optional
+
+from django.db import models
+
+if TYPE_CHECKING:
+    from endoreg_db.utils.links.requirement_link import RequirementLinks  # Added import
+
+    from ...administration.person.patient import Patient
+    from ...other.unit import Unit
+    from ..laboratory import LabValue
+    from .patient_lab_sample import PatientLabSample
+
+
+class PatientLabValue(models.Model):
+    """
+    A class representing a patient lab value.
+
+    Attributes:
+        patient (Patient): The patient.
+        lab_value (LabValue): The lab value.
+        value (float): The value of the lab value.
+        date (datetime): The date of the lab value.
+    """
+
+    patient = models.ForeignKey(
+        "Patient",
+        on_delete=models.CASCADE,
+        related_name="lab_values",
+        blank=True,
+        null=True,
+    )
+    lab_value = models.ForeignKey("LabValue", on_delete=models.CASCADE)
+    value = models.FloatField(blank=True, null=True)
+    value_str = models.CharField(max_length=255, blank=True, null=True)
+    sample = models.ForeignKey(
+        "PatientLabSample",
+        on_delete=models.CASCADE,
+        blank=True,
+        null=True,
+        related_name="values",
+    )
+    datetime = models.DateTimeField(  # if not set, use now
+        auto_now_add=True
+    )
+    normal_range = models.JSONField(default=dict)
+    unit = models.ForeignKey("Unit", on_delete=models.CASCADE, blank=True, null=True)
+
+    @property
+    def lab_value_safe(self) -> "LabValue":
+        """Returns the lab value, raises error if not set."""
+        if not self.lab_value:
+            raise ValueError("Lab value is not set.")
+        return self.lab_value
+
+    @property
+    def patient_safe(self) -> "Patient":
+        """Returns the patient, raises error if not set."""
+        if not self.patient:
+            raise ValueError("Patient is not set.")
+        return self.patient
+
+    if TYPE_CHECKING:
+        patient: models.ForeignKey["Patient|None"]
+        lab_value: models.ForeignKey["LabValue"]
+        unit: models.ForeignKey["Unit|None"]
+        sample: models.ForeignKey["PatientLabSample|None"]
+        normal_range: models.JSONField[dict]
+
+    @classmethod
+    def create_lab_value_by_sample(
+        cls,
+        sample: "PatientLabSample",
+        lab_value_name: str,
+        value: Optional[float] = None,
+        value_str: Optional[str] = None,
+        unit: Optional["Unit"] = None,
+    ):
+        from ..laboratory import LabValue
+
+        patient = sample.patient
+        lab_value = LabValue.objects.get(name=lab_value_name)
+
+        pat_lab_val = cls.objects.create(
+            patient=patient,
+            lab_value=lab_value,
+            value=value,
+            value_str=value_str,
+            sample=sample,
+            unit=unit,
+        )
+
+        pat_lab_val.save()
+
+        return pat_lab_val
+
+    def __str__(self):
+        formatted_datetime = self.datetime.strftime("%Y-%m-%d %H:%M")
+        # normal_range = self.get_normal_range()
+        norm_range_string = (
+            f"[{self.normal_range.get('min', '')} - {self.normal_range.get('max', '')}]"
+        )
+        _str = f"{self.lab_value} - {self.value} {self.unit} - {norm_range_string} ({formatted_datetime})"
+        return _str
+
+    def get_normal_range(self):
+        lab_value = self.lab_value_safe
+        patient = self.patient_safe
+
+        age = patient.age_safe
+        gender = patient.gender
+
+        normal_range_dict = lab_value.get_normal_range(age, gender)
+        return normal_range_dict
+
+    def set_min_norm_value(self, value, save=True):
+        self.normal_range["min"] = value
+        if save:
+            self.save()
+
+    def set_max_norm_value(self, value, save=True):
+        self.normal_range["max"] = value
+        if save:
+            self.save()
+
+    def set_norm_values_from_default(self):
+        normal_range_dict = self.get_normal_range()
+        self.set_min_norm_value(normal_range_dict["min"], save=False)
+        self.set_max_norm_value(normal_range_dict["max"], save=False)
+        self.save()
+
+    def set_unit_from_default(self):
+        _default_unit = self.lab_value_safe.default_unit
+        self.unit = _default_unit
+        self.save()
+
+    def get_value(self):
+        if self.value:
+            return self.value
+        else:
+            return self.value_str
+
+    def get_value_field_name(self):
+        if self.value:
+            return "value"
+        else:
+            return "value_str"
+
+    # customize save method so that if a numeric value exists, we round it to the precision of the lab value
+    def save(self, *args, **kwargs):
+        if self.value is not None:
+            # only attempt rounding for real numeric types (ints/floats/compatible)
+
+            precision = getattr(self.lab_value_safe, "numeric_precision", None)
+            if isinstance(self.value, numbers.Real) and precision is not None:
+                # ensure a plain float is passed to built-in round to satisfy type checkers
+                self.value = round(float(self.value), int(precision))
+        super().save(*args, **kwargs)
+
+    def set_value_by_distribution(self, distribution=None, save=True):
+        import warnings
+
+        from ...other.distribution import (
+            DateValueDistribution,
+            MultipleCategoricalValueDistribution,
+            NumericValueDistribution,
+            SingleCategoricalValueDistribution,
+        )
+
+        patient = self.patient_safe
+        lab_value = self.lab_value_safe
+
+        self.unit = self.lab_value_safe.default_unit
+
+        if not distribution:
+            distribution = lab_value.get_default_default_distribution()
+
+            if not distribution:
+                warnings.warn(
+                    f"No distribution set for lab value {lab_value}, assuming uniform numeric distribution based on normal values"
+                )
+
+                if not self.normal_range.get("min", None) or not self.normal_range.get(
+                    "max", None
+                ):
+                    self.set_norm_values_from_default()
+                _min = self.normal_range.get("min", 0.0001)
+                _max = self.normal_range.get("max", 100)
+                _name = (
+                    "auto-" + self.lab_value_safe.name + "-distribution-default-uniform"
+                )
+                distribution = NumericValueDistribution(
+                    name=_name,
+                    min_descriptor=_min,
+                    max_max_desciptor=_max,
+                    distribution_type="uniform",
+                )
+
+                value = distribution.generate_value(
+                    lab_value=lab_value, patient=patient
+                )
+                self.value = value
+                if save:
+                    self.save()
+
+                return value
+
+        if isinstance(distribution, SingleCategoricalValueDistribution):
+            value = distribution.generate_value()
+            self.value_str = value
+            if save:
+                self.save()
+            return value
+
+        elif isinstance(distribution, NumericValueDistribution):
+            value = distribution.generate_value(lab_value=lab_value, patient=patient)
+            self.value = value
+            if save:
+                self.save()
+            return value
+
+        elif isinstance(distribution, MultipleCategoricalValueDistribution):
+            value = distribution.generate_value()
+            self.value_str = value
+            if save:
+                self.save()
+            return value
+
+        elif isinstance(distribution, DateValueDistribution):
+            # raise not implemented error
+            value = distribution.generate_value()
+            self.value = value
+            if save:
+                self.save()
+            return value
+
+    @property
+    def links(self) -> "RequirementLinks":
+        """
+        Aggregates and returns all related model instances relevant for requirement evaluation
+        as a RequirementLinks object.
+        """
+        from endoreg_db.utils.links.requirement_link import RequirementLinks
+
+        return RequirementLinks(
+            patient_lab_values=[self]  # Include the lab value itself
+        )

endoreg_db/models/medical/patient/patient_medication.py

@@ -0,0 +1,111 @@
+from typing import TYPE_CHECKING, List, cast  # Added List
+
+from django.db import models
+
+# Added imports for type hints
+if TYPE_CHECKING:
+    from ....utils.links.requirement_link import (
+        RequirementLinks,
+    )  # Added RequirementLinks
+    from ...administration.person.patient import Patient
+    from ...other.unit import Unit
+    from ..medication import Medication, MedicationIndication, MedicationIntakeTime
+
+
+class PatientMedication(models.Model):
+    """
+    Represents a specific medication prescribed or taken by a patient.
+
+    Links a patient to a medication, its indication, dosage, intake times, and unit.
+    """
+
+    patient = models.ForeignKey("Patient", on_delete=models.CASCADE)
+    medication_indication = models.ForeignKey(
+        "MedicationIndication",
+        on_delete=models.CASCADE,
+        related_name="indication_patient_medications",
+        null=True,
+    )
+
+    medication = models.ForeignKey(
+        "Medication",
+        on_delete=models.CASCADE,
+        blank=True,
+        related_name="medication_patient_medications",
+    )
+
+    intake_times = models.ManyToManyField(
+        "MedicationIntakeTime",
+        related_name="intake_time_patient_medications",
+        blank=True,
+    )
+
+    unit = models.ForeignKey("Unit", on_delete=models.CASCADE, null=True, blank=True)
+    dosage = models.JSONField(null=True, blank=True)
+    active = models.BooleanField(default=True)
+
+    objects = models.Manager()
+
+    if TYPE_CHECKING:  # Added type hints block
+        patient: models.ForeignKey["Patient"]
+        medication_indication: models.ForeignKey["MedicationIndication|None"]
+        medication: models.ForeignKey["Medication|None"]
+
+        intake_times = cast(
+            models.manager.RelatedManager["MedicationIntakeTime"], intake_times
+        )
+        unit: models.ForeignKey["Unit|None"]
+        dosage = cast(models.JSONField, dosage)
+
+    @property
+    def links(self) -> "RequirementLinks":
+        """
+        Returns a RequirementLinks object for this PatientMedication instance.
+        This is used during requirement evaluation.
+        """
+        from ....utils.links.requirement_link import RequirementLinks
+
+        meds: List["Medication"] = []
+        if self.medication:
+            meds.append(self.medication)
+
+        indications: List["MedicationIndication"] = []
+        if self.medication_indication:
+            indications.append(self.medication_indication)
+
+        intake_times_list: List["MedicationIntakeTime"] = list(self.intake_times.all())
+
+        return RequirementLinks(
+            medications=meds,
+            medication_indications=indications,
+            medication_intake_times=intake_times_list,
+            patient_medications=[self],  # Include self in patient_medications
+        )
+
+    class Meta:
+        verbose_name = "Patient Medication"
+        verbose_name_plural = "Patient Medications"
+
+    @classmethod
+    def create_by_patient_and_indication(
+        cls, patient, medication_indication: "MedicationIndication"
+    ):
+        """Creates a PatientMedication instance linking a patient and an indication."""
+
+        patient_medication = cls.objects.create(
+            patient=patient, medication_indication=medication_indication
+        )
+        patient_medication.save()
+
+        return patient_medication
+
+    def __str__(self):
+        """Returns a string representation including medication, indication, dosage, and intake times."""
+        intake_times = self.intake_times.all()
+        out = f"{self.medication} (Indication {self.medication_indication}) - "
+        out += f"{self.dosage} - {self.unit} - "
+
+        for intake_time in intake_times:
+            out += f"{intake_time} - "
+
+        return out

endoreg_db/models/medical/patient/patient_medication_schedule.py

@@ -0,0 +1,152 @@
+from django.db import models
+from typing import TYPE_CHECKING, List, cast  # Added List
+from datetime import datetime as dt
+
+if TYPE_CHECKING:
+    from ...administration.person.patient import Patient
+    from .patient_medication import PatientMedication
+    from ..medication import MedicationSchedule
+    from ....utils.links.requirement_link import RequirementLinks  # Added
+    from ..medication import (
+        Medication,
+        MedicationIndication,
+        MedicationIntakeTime,
+    )  # Added
+
+
+class PatientMedicationSchedule(models.Model):
+    """
+    Represents a collection of medications associated with a patient, forming their schedule.
+    """
+
+    patient = models.ForeignKey("Patient", on_delete=models.CASCADE)
+    medication = models.ManyToManyField(
+        "PatientMedication", related_name="patient_medication_schedules", blank=True
+    )
+
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+
+    if TYPE_CHECKING:
+        patient: models.ForeignKey["Patient"]
+
+        medication = cast(
+            models.manager.RelatedManager["PatientMedication"], medication
+        )
+
+    @property
+    def links(self) -> "RequirementLinks":
+        """
+        Aggregates RequirementLinks from all PatientMedication instances in this schedule.
+        """
+        from ....utils.links.requirement_link import RequirementLinks
+
+        aggregated_medications: List["Medication"] = []
+        aggregated_medication_indications: List["MedicationIndication"] = []
+        aggregated_medication_intake_times: List["MedicationIntakeTime"] = []
+
+        patient_meds_in_schedule: List["PatientMedication"] = list(
+            self.medication.all()
+        )
+
+        for pm_instance in patient_meds_in_schedule:
+            pm_links_obj = pm_instance.links
+
+            aggregated_medications.extend(pm_links_obj.medications)
+            aggregated_medication_indications.extend(
+                pm_links_obj.medication_indications
+            )
+            aggregated_medication_intake_times.extend(
+                pm_links_obj.medication_intake_times
+            )
+
+        return RequirementLinks(
+            medications=list(set(aggregated_medications)),
+            medication_indications=list(set(aggregated_medication_indications)),
+            medication_intake_times=list(set(aggregated_medication_intake_times)),
+            patient_medications=patient_meds_in_schedule,
+            patient_medication_schedules=[self],
+        )
+
+    def __str__(self):
+        """Returns a string representation including the patient and associated medications."""
+        return f"{self.patient} - {self.medication.all()}"
+
+    @classmethod
+    def create_by_patient_and_indication_type(cls, patient, indication_type):
+        """Creates a schedule and adds a medication based on a random indication of a given type."""
+        from ..medication import MedicationIndicationType
+        from .patient_medication import PatientMedication
+
+        medication_indication = MedicationIndicationType.get_random_indication_by_type(
+            name=indication_type
+        )
+
+        patient_medication_schedule = cls.objects.create(patient=patient)
+        patient_medication_schedule.save()
+
+        patient_medication = PatientMedication.create_by_patient_and_indication(
+            patient, medication_indication
+        )
+        patient_medication_schedule.medication.add(patient_medication)
+        patient_medication_schedule.save()
+
+        return patient_medication_schedule
+
+    @classmethod
+    def create_by_patient_and_indication(cls, patient, medication_indication):
+        """Creates a schedule and adds a medication based on a specific indication."""
+        from ..medication import MedicationIndication
+        from .patient_medication import PatientMedication
+        from ...administration.person.patient import Patient
+
+        assert isinstance(medication_indication, MedicationIndication)
+        assert isinstance(patient, Patient)
+        patient_medication_schedule = cls.objects.create(patient=patient)
+        patient_medication_schedule.save()
+
+        patient_medication = PatientMedication.create_by_patient_and_indication(
+            patient, medication_indication
+        )
+        patient_medication_schedule.medication.add(patient_medication)
+        patient_medication_schedule.save()
+
+        return patient_medication_schedule
+
+    def create_patient_medication_from_medication_schedule(
+        self,
+        medication_schedule: "MedicationSchedule",
+        medication_indication=None,
+        start_date=None,
+    ):
+        """Creates and adds a PatientMedication based on a generic MedicationSchedule template."""
+
+        from .patient_medication import PatientMedication
+
+        if not start_date:
+            start_date = dt.now()
+
+        drug = medication_schedule.medication
+        unit = medication_schedule.unit
+        dosage = medication_schedule.dose
+        intake_times = medication_schedule.get_intake_times()
+
+        patient_medication = PatientMedication.objects.create(
+            patient=self.patient,
+            medication=drug,
+            medication_indication=medication_indication,
+            unit=unit,
+            dosage=dosage,
+        )
+
+        patient_medication.intake_times.set(intake_times)
+        patient_medication.save()
+
+        self.medication.add(patient_medication)
+        self.save()
+
+        return patient_medication
+
+    def get_patient_medication(self):
+        """Returns all PatientMedication instances associated with this schedule."""
+        return self.medication.all()

endoreg_db/models/medical/risk/__init__.py

@@ -0,0 +1,7 @@
+from .risk import Risk
+from .risk_type import RiskType
+
+__all__ = [
+    "Risk",
+    "RiskType",
+]