endoreg-db 0.8.6.1__py3-none-any.whl → 0.8.8.0__py3-none-any.whl

endoreg_db/models/medical/patient/patient_lab_value.py

@@ -1,12 +1,16 @@
-from django.db import models
+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 ..laboratory import LabValue
     from ...other.unit import Unit
+    from ..laboratory import LabValue
     from .patient_lab_sample import PatientLabSample
-    from endoreg_db.utils.links.requirement_link import RequirementLinks # Added import
+
 
 class PatientLabValue(models.Model):
     """
@@ -18,50 +22,55 @@ class PatientLabValue(models.Model):
         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)
+
+    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        
+    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)
+    normal_range = models.JSONField(default=dict)
+    unit = models.ForeignKey("Unit", on_delete=models.CASCADE, blank=True, null=True)
 
-    if TYPE_CHECKING:
+    @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
 
-        patient: "Patient"
-        lab_value: "LabValue"
-        unit: "Unit"
-        sample: "PatientLabSample"
+    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
+        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,
+            patient=patient,
+            lab_value=lab_value,
+            value=value,
+            value_str=value_str,
+            sample=sample,
+            unit=unit,
         )
 
         pat_lab_val.save()
@@ -69,44 +78,41 @@ class PatientLabValue(models.Model):
         return pat_lab_val
 
     def __str__(self):
-        formatted_datetime = self.datetime.strftime('%Y-%m-%d %H:%M')
+        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})'
+        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
+        lab_value = self.lab_value_safe
+        patient = self.patient_safe
 
-        age = patient.age()
+        age = patient.age_safe
         gender = patient.gender
 
-        normal_range_dict = lab_value.get_normal_range(
-            age,gender
-        )
+        normal_range_dict = lab_value.get_normal_range(age, gender)
         return normal_range_dict
 
-    
-    def set_min_norm_value(self, value, save = True):
+    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):
+    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.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
+        _default_unit = self.lab_value_safe.default_unit
+        self.unit = _default_unit
         self.save()
 
     def get_value(self):
@@ -114,65 +120,57 @@ class PatientLabValue(models.Model):
             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)
+        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):
-        from ...administration.person.patient import Patient
-        from ..laboratory import LabValue
+    def set_value_by_distribution(self, distribution=None, save=True):
+        import warnings
+
         from ...other.distribution import (
             DateValueDistribution,
-            SingleCategoricalValueDistribution,
-            NumericValueDistribution,
             MultipleCategoricalValueDistribution,
-        ) 
-        import warnings  
-
-        patient:Patient = self.patient
+            NumericValueDistribution,
+            SingleCategoricalValueDistribution,
+        )
 
-        lab_value:LabValue = self.lab_value
+        patient = self.patient_safe
+        lab_value = self.lab_value_safe
 
-        assert self.lab_value, "Lab value must be set to set value by distribution"
-        self.unit = self.lab_value.default_unit
+        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"
-                )
+                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"
-                )
+                _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):
@@ -181,17 +179,14 @@ class PatientLabValue(models.Model):
             if save:
                 self.save()
             return value
-        
+
         elif isinstance(distribution, NumericValueDistribution):
-            value = distribution.generate_value(
-                lab_value=lab_value,
-                patient=patient
-            )
+            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
@@ -216,7 +211,5 @@ class PatientLabValue(models.Model):
         from endoreg_db.utils.links.requirement_link import RequirementLinks
 
         return RequirementLinks(
-            patient_lab_values=[self] # Include the lab value itself
+            patient_lab_values=[self]  # Include the lab value itself
         )
-
-

endoreg_db/models/medical/patient/patient_medication.py

@@ -1,12 +1,14 @@
+from typing import TYPE_CHECKING, List, Optional, cast  # Added List
+
 from django.db import models
-from typing import TYPE_CHECKING, Optional, List  # Added List
 
 # Added imports for type hints
 if TYPE_CHECKING:
+    from ....utils.links.requirement_link import RequirementLinks  # Added RequirementLinks
     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
+    from ..medication import Medication, MedicationIndication, MedicationIntakeTime
+
 
 class PatientMedication(models.Model):
     """
@@ -14,42 +16,32 @@ class PatientMedication(models.Model):
 
     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_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'
-    )
+    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',
+        "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
-    )
+    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]
+        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":
@@ -58,11 +50,11 @@ class PatientMedication(models.Model):
         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)
@@ -73,23 +65,21 @@ class PatientMedication(models.Model):
             medications=meds,
             medication_indications=indications,
             medication_intake_times=intake_times_list,
-            patient_medications=[self] # Include self in patient_medications
+            patient_medications=[self],  # Include self in patient_medications
         )
 
     class Meta:
-        verbose_name = 'Patient Medication'
-        verbose_name_plural = 'Patient Medications'
+        verbose_name = "Patient Medication"
+        verbose_name_plural = "Patient Medications"
 
     @classmethod
-    def create_by_patient_and_indication(cls, patient, medication_indication):
+    def create_by_patient_and_indication(cls, patient, medication_indication: "MedicationIndication"):
         """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
 
+        return patient_medication
 
     def __str__(self):
         """Returns a string representation including medication, indication, dosage, and intake times."""
@@ -101,4 +91,3 @@ class PatientMedication(models.Model):
             out += f"{intake_time} - "
 
         return out
-

endoreg_db/models/medical/patient/patient_medication_schedule.py

@@ -1,32 +1,30 @@
 from django.db import models
-from typing import TYPE_CHECKING, List # Added List
+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
+    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
-    )
+
+    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"]
+        patient: models.ForeignKey["Patient"]
+
+        medication = cast(models.manager.RelatedManager["PatientMedication"], medication)
 
     @property
     def links(self) -> "RequirementLinks":
@@ -38,12 +36,12 @@ class PatientMedicationSchedule(models.Model):
         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 
-            
+            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)
@@ -53,13 +51,13 @@ class PatientMedicationSchedule(models.Model):
             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]
+            patient_medication_schedules=[self],
         )
 
     def __str__(self):
         """Returns a string representation including the patient and associated medications."""
-        return f'{self.patient} - {self.medication.all()}'
-    
+        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."""
@@ -76,7 +74,7 @@ class PatientMedicationSchedule(models.Model):
         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."""
@@ -84,7 +82,6 @@ class PatientMedicationSchedule(models.Model):
         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)
@@ -95,17 +92,17 @@ class PatientMedicationSchedule(models.Model):
         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,
-        ):
+        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()
 
@@ -115,22 +112,17 @@ class PatientMedicationSchedule(models.Model):
         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=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()  
+        self.save()
 
         return patient_medication
-    
-    
+
     def get_patient_medication(self):
         """Returns all PatientMedication instances associated with this schedule."""
-        return self.medication.all()
+        return self.medication.all()

endoreg_db/models/medical/risk/risk.py

@@ -1,15 +1,16 @@
+from typing import TYPE_CHECKING
+
 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.
         """
@@ -49,14 +50,14 @@ class Risk(models.Model):
     objects = RiskManager()
 
     if TYPE_CHECKING:
-        from endoreg_db.models.risk.risk_type import RiskType
+        from endoreg_db.models 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.
         """
@@ -65,7 +66,7 @@ class Risk(models.Model):
     def __str__(self):
         """
         Return the string representation of the risk.
-        
+
         Returns:
             str: The risk's name.
         """

endoreg_db/models/medical/risk/risk_type.py

@@ -1,15 +1,18 @@
-from django.db import models
 from typing import TYPE_CHECKING
 
+from django.db import models
+
+# Deorecate ?
+
 
 class RiskTypeManager(models.Manager):
     def get_by_natural_key(self, name):
         """
         Retrieves a RiskType instance using its natural key.
-        
+
         Args:
             name (str): The unique name identifying the RiskType instance.
-        
+
         Returns:
             RiskType: The matching instance with the provided name.
         """
@@ -31,14 +34,14 @@ class RiskType(models.Model):
     objects = RiskTypeManager()
 
     if TYPE_CHECKING:
-        from endoreg_db.models.risk.risk import Risk
+        from endoreg_db.models import Risk
 
         risks: models.QuerySet[Risk]
 
     def natural_key(self):
         """
         Return the natural key for this risk type.
-        
+
         This method returns a tuple containing only the risk type's unique name, which is used
         to identify the instance naturally.
         """