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

endoreg_db/models/medical/patient/patient_finding_classification.py

@@ -1,50 +1,40 @@
-from django.db import models
-from typing import TYPE_CHECKING, Dict
 import random
-import numpy as np
+from typing import TYPE_CHECKING, Dict
 
+import numpy as np
+from django.db import models
 
 # Corrected imports for type hints
 if TYPE_CHECKING:
     from ..finding import (
-        FindingClassification, 
-        FindingClassificationChoice, 
+        FindingClassification,
+        FindingClassificationChoice,
     )
     from .patient_finding import PatientFinding
 
+
 class PatientFindingClassification(models.Model):
     """Represents basic classifications for specific findings in a patient context.
     Links a PatientFinding to a specific classification and choice, with optional subcategory values.
     """
-    finding = models.ForeignKey( # type: ignore[assignment]
-        "PatientFinding", 
-        on_delete=models.CASCADE, 
-        related_name="classifications"
-    )
-    classification = models.ForeignKey( # type: ignore[assignment]
-        "FindingClassification", 
-        on_delete=models.CASCADE, 
-        related_name="patient_finding_classifications"
-    )
-    classification_choice = models.ForeignKey( # type: ignore[assignment]
-        "FindingClassificationChoice", 
-        on_delete=models.CASCADE, 
-        related_name="patient_finding_classifications"
-    )
+
+    finding = models.ForeignKey("PatientFinding", on_delete=models.CASCADE, related_name="classifications")
+    classification = models.ForeignKey("FindingClassification", on_delete=models.CASCADE, related_name="patient_finding_classifications")
+    classification_choice = models.ForeignKey("FindingClassificationChoice", on_delete=models.CASCADE, related_name="patient_finding_classifications")
 
     is_active = models.BooleanField(default=True, help_text="Indicates if the classification is currently active.")
     subcategories = models.JSONField(blank=True, null=True)
     numerical_descriptors = models.JSONField(blank=True, null=True)
 
     if TYPE_CHECKING:
-        finding: "PatientFinding"
-        classification: "FindingClassification"
-        classification_choice: "FindingClassificationChoice"
+        finding: models.ForeignKey["PatientFinding"]
+        classification: models.ForeignKey["FindingClassification"]
+        classification_choice: models.ForeignKey["FindingClassificationChoice"]
 
     class Meta:
-        verbose_name = 'Patient Finding Classification'
-        verbose_name_plural = 'Patient Finding Classifications'
-        ordering = ['finding', 'classification', 'classification_choice']
+        verbose_name = "Patient Finding Classification"
+        verbose_name_plural = "Patient Finding Classifications"
+        ordering = ["finding", "classification", "classification_choice"]
 
     def __str__(self):
         """
@@ -55,7 +45,7 @@ class PatientFindingClassification(models.Model):
     def save(self, *args, **kwargs):
         """
         Saves the model instance after validating and initializing classification-related fields.
-        
+
         Ensures that the selected classification choice is valid for the associated classification. If subcategories or numerical descriptors are unset, initializes them from the classification choice before saving.
         """
         if self.classification_choice not in self.classification.choices.all():
@@ -72,7 +62,7 @@ class PatientFindingClassification(models.Model):
     def initialize_and_get_subcategories(self):
         """
         Ensure the subcategories field is initialized and return its dictionary.
-        
+
         Returns:
             dict: The subcategories associated with this classification.
         """
@@ -83,43 +73,46 @@ class PatientFindingClassification(models.Model):
     def initialize_and_get_descriptors(self):
         """
         Return the numerical descriptors dictionary, initializing it if necessary.
-        
+
         If the `numerical_descriptors` field is empty or uninitialized, the method triggers model initialization and returns the resulting dictionary.
         """
         if not self.numerical_descriptors:
             self.save()
         return self.numerical_descriptors
 
-    def set_subcategory(self, subcategory_name: str, subcategory_value: Dict):
+    def set_subcategory(self, subcategory_name: str, subcategory_value: Dict[str, dict]):
         """
         Update the value of a specified subcategory and save the classification.
-        
+
         Parameters:
             subcategory_name (str): The name of the subcategory to update.
             subcategory_value (dict): The value to assign to the subcategory.
-        
+
         Returns:
             dict: The updated subcategory dictionary.
         """
+        assert self.subcategories, "Subcategories must be initialized."
         assert subcategory_name in self.subcategories, "Subcategory must be in subcategories."
         self.subcategories[subcategory_name]["value"] = subcategory_value
         self.save()
 
         return self.subcategories[subcategory_name]
-    
+
     def set_random_subcategories(self):
         """
         Assign random values to all required subcategories that do not already have a value.
-        
+
         For each required subcategory without a value, selects a random option from its available choices, updates the subcategory, saves the model, and returns the updated subcategories dictionary.
-        
+
         Returns:
             dict: The updated subcategories with random values assigned where needed.
         """
+
         if not self.subcategories or not self.numerical_descriptors:
             self.save()
-        
+
         self.refresh_from_db()
+        assert self.subcategories is not None, "Subcategories must be initialized."
 
         for subcategory_name, subcategory_dict in self.subcategories.items():
             if subcategory_dict["required"] and not subcategory_dict.get("value", None):
@@ -129,21 +122,21 @@ class PatientFindingClassification(models.Model):
         self.save()
 
         return self.subcategories
-    
-    def get_random_value_for_numerical_descriptor(self, descriptor_name):
 
+    def get_random_value_for_numerical_descriptor(self, descriptor_name):
         """
         Generate a random value for the specified numerical descriptor using its defined distribution parameters.
-        
+
         Parameters:
             descriptor_name (str): The name of the numerical descriptor to generate a value for.
-        
+
         Returns:
             float: A randomly generated value based on the descriptor's distribution, clipped to its min and max range.
-        
+
         Raises:
             ValueError: If the descriptor's distribution type is not supported.
-        """  
+        """
+        assert self.numerical_descriptors is not None, "Numerical descriptors must be initialized."
         assert descriptor_name in self.numerical_descriptors, "Descriptor must be in numerical descriptors."
         descriptor = self.numerical_descriptors[descriptor_name]
         min_val = descriptor.get("min", 0)
@@ -159,20 +152,20 @@ class PatientFindingClassification(models.Model):
             value = np.random.uniform(min_val, max_val)
         else:
             raise ValueError("Distribution not supported")
-        
+
         return value
 
     def set_random_numerical_descriptor(self, descriptor_name, save=True):
         """
         Assigns a random value to the specified numerical descriptor and optionally saves the model.
-        
+
         Parameters:
             descriptor_name (str): The name of the numerical descriptor to update.
             save (bool): If True, saves the model after updating the descriptor. Defaults to True.
-        
+
         Returns:
             dict: The updated numerical descriptor dictionary with the new random value.
-        
+
         Raises:
             ValueError: If the descriptor name is not present in the numerical descriptors.
         """
@@ -180,23 +173,25 @@ class PatientFindingClassification(models.Model):
             raise ValueError("Descriptor name must be in numerical descriptors.")
 
         value = self.get_random_value_for_numerical_descriptor(descriptor_name)
-        
+        assert self.numerical_descriptors is not None, "Numerical descriptors must be initialized."
         self.numerical_descriptors[descriptor_name]["value"] = value
         if save:
             self.save()
 
         return self.numerical_descriptors[descriptor_name]
-    
+
     def set_random_numerical_descriptors(self):
         """
         Assigns random values to all numerical descriptors and saves the model.
-        
+
         Returns:
             dict: The updated numerical_descriptors dictionary with assigned random values.
         """
         if not self.subcategories or not self.numerical_descriptors:
             self.save()
 
+        assert self.numerical_descriptors is not None, "Numerical descriptors must be initialized."
+
         numerical_descriptors = self.numerical_descriptors
 
         for numerical_descriptor_name, _numerical_descriptor_dict in numerical_descriptors.items():

endoreg_db/models/medical/patient/patient_finding_intervention.py

@@ -1,40 +1,29 @@
-from operator import is_
-from django.db import models 
 from typing import TYPE_CHECKING
 
+from django.db import models
+
 if TYPE_CHECKING:
     from ..finding import FindingIntervention
     from .patient_finding import PatientFinding
 
+
 class PatientFindingIntervention(models.Model):
-    finding = models.ForeignKey(
-        'PatientFinding', 
-        on_delete=models.CASCADE, 
-        related_name='interventions'
-    )
-    intervention = models.ForeignKey(
-        'FindingIntervention',
-        on_delete=models.CASCADE,
-        related_name='patient_finding_interventions'
-    )
-    is_active = models.BooleanField(
-        default=True, 
-        help_text="Indicates if the intervention is currently active."
-    )
+    finding = models.ForeignKey("PatientFinding", on_delete=models.CASCADE, related_name="interventions")
+    intervention = models.ForeignKey("FindingIntervention", on_delete=models.CASCADE, related_name="patient_finding_interventions")
+    is_active = models.BooleanField(default=True, help_text="Indicates if the intervention is currently active.")
     state = models.CharField(max_length=100, blank=True, null=True)
     time_start = models.DateTimeField(blank=True, null=True)
     time_end = models.DateTimeField(blank=True, null=True)
     date = models.DateField(blank=True, null=True)
 
     if TYPE_CHECKING:
-        finding: "PatientFinding"
-        intervention: "FindingIntervention"
+        finding: models.ForeignKey["PatientFinding"]
+        intervention: models.ForeignKey["FindingIntervention"]
 
     def __str__(self):
         return self.intervention.name
 
     def natural_key(self):
         return (self.intervention.name,)
-    
 
     objects = models.Manager()

endoreg_db/models/medical/patient/patient_lab_sample.py

@@ -1,19 +1,24 @@
-from django.db import models
+from datetime import datetime as dt
+from datetime import timezone
 from typing import TYPE_CHECKING
-from datetime import datetime as dt, timezone
+
+from django.db import models
 
 if TYPE_CHECKING:
-    from endoreg_db.models import Patient, LabValue, PatientLabValue
-    from endoreg_db.utils.links.requirement_link import RequirementLinks # Added import
+    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).
@@ -22,6 +27,7 @@ class PatientLabSampleType(models.Model):
         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)
 
@@ -34,12 +40,13 @@ class PatientLabSampleType(models.Model):
     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.
@@ -52,24 +59,27 @@ class PatientLabSample(models.Model):
         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"]
+        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')
+        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":
         """
@@ -84,11 +94,11 @@ class PatientLabSample(models.Model):
 
         return RequirementLinks(
             patient_lab_values=patient_lab_values,
-            patient_lab_samples=[self] # Include the sample itself
+            patient_lab_samples=[self],  # Include the sample itself
         )
 
     @classmethod
-    def create_by_patient(cls, patient=None, sample_type=None, date=None, save = True):
+    def create_by_patient(cls, patient=None, sample_type=None, date=None, save=True):
         """
         Creates a new patient lab sample for a given patient.
 
@@ -115,26 +125,22 @@ class PatientLabSample(models.Model):
         if not date:
             date = dt.now(timezone.utc)
 
-        patient_lab_sample = cls.objects.create(
-            patient=patient,
-            sample_type=sample_type,
-            date=date
-        )
+        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"):
+    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
+        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(
@@ -142,7 +148,6 @@ class PatientLabSample(models.Model):
             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
+            unit=lab_value.default_unit,  # Use the unit from the lab value
         )
         return patient_lab_value
-