endoreg-db 0.8.6.4__py3-none-any.whl

endoreg_db/models/medical/patient/patient_lab_sample.py

@@ -0,0 +1,148 @@
+from django.db import models
+from typing import TYPE_CHECKING
+from datetime import datetime as dt, timezone
+
+if TYPE_CHECKING:
+    from endoreg_db.models import Patient, LabValue, 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: "Patient"
+        sample_type: "PatientLabSampleType"
+        values: models.QuerySet["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 PatientLabValue, LabValue
+        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,222 @@
+from django.db import models
+from typing import TYPE_CHECKING, Optional
+
+if TYPE_CHECKING:
+    from ...administration.person.patient import Patient
+    from ..laboratory import LabValue
+    from ...other.unit import Unit
+    from .patient_lab_sample import PatientLabSample
+    from endoreg_db.utils.links.requirement_link import RequirementLinks # Added import
+
+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"] = 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)
+
+    if TYPE_CHECKING:
+
+        patient: "Patient"
+        lab_value: "LabValue"
+        unit: "Unit"
+        sample: "PatientLabSample"
+
+    @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
+        patient = self.patient
+
+        age = patient.age()
+        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):
+        self.unit = self.lab_value.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:
+            precision = self.lab_value.numeric_precision
+            self.value = round(self.value, precision)
+        super().save(*args, **kwargs)
+
+    def set_value_by_distribution(self, distribution=None, save = True):
+        from ...administration.person.patient import Patient
+        from ..laboratory import LabValue
+        from ...other.distribution import (
+            DateValueDistribution,
+            SingleCategoricalValueDistribution,
+            NumericValueDistribution,
+            MultipleCategoricalValueDistribution,
+        ) 
+        import warnings  
+
+        patient:Patient = self.patient
+
+        lab_value:LabValue = self.lab_value
+
+        assert self.lab_value, "Lab value must be set to set value by distribution"
+        self.unit = self.lab_value.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()
+
+                self.normal_range:dict
+                _min = self.normal_range.get("min", 0.0001)
+                _max = self.normal_range.get("max", 100)
+                _name = "auto-" + self.lab_value.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,104 @@
+from django.db import models
+from typing import TYPE_CHECKING, Optional, List  # Added List
+
+# Added imports for type hints
+if TYPE_CHECKING:
+    from ...administration.person.patient import Patient
+    from ..medication import MedicationIndication, Medication, MedicationIntakeTime
+    from ...other.unit import Unit
+    from ....utils.links.requirement_link import RequirementLinks # Added RequirementLinks
+
+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: "Patient"
+        medication_indication: Optional["MedicationIndication"]
+        medication: Optional["Medication"]
+        intake_times: models.QuerySet["MedicationIntakeTime"]
+        unit: Optional["Unit"]
+        dosage: Optional[dict]
+
+    @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):
+        """Creates a PatientMedication instance linking a patient and an indication."""
+        from ..medication import MedicationIndication
+        medication_indication: MedicationIndication
+        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,136 @@
+from django.db import models
+from typing import TYPE_CHECKING, List # 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: "Patient"
+        medication: models.QuerySet["PatientMedication"]
+
+    @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",
+]

endoreg_db/models/medical/risk/risk.py

@@ -0,0 +1,72 @@
+from django.db import models
+from typing import List, TYPE_CHECKING
+
+
+class RiskManager(models.Manager):
+    def get_by_natural_key(self, name):
+        """
+        Retrieve a risk instance using its natural key.
+        
+        Args:
+            name: The unique name identifying the risk instance.
+        
+        Returns:
+            The risk instance with the matching name.
+        """
+        return self.get(name=name)
+
+
+class Risk(models.Model):
+    """
+    A class representing a risk.
+
+    Attributes:
+        name (str): The name of the risk.
+        name_de (str): The German name of the risk.
+        name_en (str): The English name of the risk.
+        description (str): A description of the risk.
+    """
+
+    name = models.CharField(max_length=100, unique=True)
+    name_de = models.CharField(max_length=100, blank=True, null=True)
+    name_en = models.CharField(max_length=100, blank=True, null=True)
+    description = models.TextField(blank=True, null=True)
+
+    risk_value = models.FloatField(
+        blank=True,
+        null=True,
+        help_text="Risk value for the risk. If not set, the risk is not used in calculations.",
+    )
+
+    risk_type = models.ForeignKey(
+        "RiskType",
+        on_delete=models.CASCADE,
+        related_name="risks",
+        blank=True,
+        null=True,
+    )
+
+    objects = RiskManager()
+
+    if TYPE_CHECKING:
+        from endoreg_db.models.risk.risk_type import RiskType
+
+        risk_types: RiskType
+
+    def natural_key(self):
+        """
+        Return a tuple containing the natural key of the risk instance.
+        
+        The tuple consists of the unique 'name' attribute, which enables natural key lookups
+        and serialization within Django.
+        """
+        return (self.name,)
+
+    def __str__(self):
+        """
+        Return the string representation of the risk.
+        
+        Returns:
+            str: The risk's name.
+        """
+        return str(self.name)