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

endoreg_db/models/medical/medication/medication_indication_type.py

@@ -1,39 +1,50 @@
-'''Model for medication indication type.'''
-from django.db import models
+"""Model for medication indication type."""
+
 from typing import TYPE_CHECKING
 
+from django.db import models
+
 if TYPE_CHECKING:
     from endoreg_db.models import MedicationIndication
 
+
 class MedicationIndicationTypeManager(models.Manager):
-    '''Manager for the medication indication type model.'''
+    """Manager for the medication indication type model."""
+
     def get_by_natural_key(self, name):
-        '''Retrieve a medication indication type by its natural key.'''
+        """Retrieve a medication indication type by its natural key."""
         return self.get(name=name)
 
+
 class MedicationIndicationType(models.Model):
-    '''Model representing a medication indication type.'''
-    name = models.CharField(max_length=255, unique=True) 
+    """Model representing a medication indication type."""
+
+    name = models.CharField(max_length=255, unique=True)
 
     objects = MedicationIndicationTypeManager()
 
     if TYPE_CHECKING:
-        medication_indications: models.QuerySet["MedicationIndication"]
+
+        @property
+        def medication_indications(self) -> "models.manager.RelatedManager[MedicationIndication]": ...
 
     def natural_key(self):
-        '''Return the natural key for the medication indication type.'''
+        """Return the natural key for the medication indication type."""
         return (self.name,)
 
     def __str__(self):
         return str(self.name)
-    
+
     @classmethod
     def get_random_indication_by_type(cls, name) -> "MedicationIndication":
-        '''Return a random medication indication of the given type.'''
-        return cls.objects.get(name=name).medication_indications.order_by('?').first()
-    
+        """Return a random medication indication of the given type."""
+        med_indication = cls.objects.get(name=name).medication_indications.order_by("?").first()
+        if not med_indication:
+            raise cls.DoesNotExist(f"No medication indication found for type: {name}")
+        return med_indication
 
     def get_random_medication_indication(self):
-        '''Return a random medication indication of this type.'''
+        """Return a random medication indication of this type."""
         from endoreg_db.models import MedicationIndication
-        return MedicationIndication.objects.filter(indication_type=self).order_by('?').first()
+
+        return MedicationIndication.objects.filter(indication_type=self).order_by("?").first()

endoreg_db/models/medical/medication/medication_intake_time.py

@@ -1,44 +1,56 @@
-'''Model for medication intake time'''
+"""Model for medication intake time"""
+
+from typing import TYPE_CHECKING
+
 from django.db import models
 
 
 class MedicationIntakeTimeManager(models.Manager):
-    '''Manager for the medication intake time model.'''
+    """Manager for the medication intake time model."""
+
     def get_by_natural_key(self, name):
-        '''Retrieve a medication intake time by its natural key.'''
+        """Retrieve a medication intake time by its natural key."""
         return self.get(name=name)
-    
+
+
 class MedicationIntakeTime(models.Model):
-    '''Model representing a medication intake time.'''
-    name = models.CharField(max_length=255, unique=True)  # Made unique=True 
-    repeats = models.CharField(max_length=20, default = "daily")
+    """Model representing a medication intake time."""
+
+    name = models.CharField(max_length=255, unique=True)  # Made unique=True
+    repeats = models.CharField(max_length=20, default="daily")
     time = models.TimeField()
 
     objects = MedicationIntakeTimeManager()
 
+    if TYPE_CHECKING:
+        from endoreg_db.models import MedicationSchedule
+
+        @property
+        def medication_schedules(self) -> "models.manager.RelatedManager[MedicationSchedule]": ...
+
     @classmethod
     def dm(cls):
-        '''Return the daily morning intake time object.'''
-        return cls.objects.get(name='daily-morning')
-    
+        """Return the daily morning intake time object."""
+        return cls.objects.get(name="daily-morning")
+
     @classmethod
     def dno(cls):
-        '''Return the daily noon intake time object.'''
-        return cls.objects.get(name='daily-noon')
+        """Return the daily noon intake time object."""
+        return cls.objects.get(name="daily-noon")
 
     @classmethod
     def de(cls):
-        '''Return the daily evening intake time object.'''
-        return cls.objects.get(name='daily-evening')
-    
+        """Return the daily evening intake time object."""
+        return cls.objects.get(name="daily-evening")
+
     @classmethod
     def dn(cls):
-        '''Return the daily night intake time object.'''
-        return cls.objects.get(name='daily-night')
+        """Return the daily night intake time object."""
+        return cls.objects.get(name="daily-night")
 
     def natural_key(self):
-        '''Return the natural key for the medication intake time.'''
+        """Return the natural key for the medication intake time."""
         return (self.name,)
-    
+
     def __str__(self):
         return self.name + " at " + str(self.time) + " (" + self.repeats + ")"

endoreg_db/models/medical/medication/medication_schedule.py

@@ -1,45 +1,56 @@
-'''Model for the medication schedule.'''
-from typing import List, TYPE_CHECKING
+"""Model for the medication schedule."""
+
+from typing import TYPE_CHECKING, List, cast
+
 from django.db import models
 
 if TYPE_CHECKING:
-    from endoreg_db.models import MedicationIntakeTime
+    from endoreg_db.models import Medication, MedicationIntakeTime, Unit
+
+
 class MedicationScheduleManager(models.Manager):
-    '''Manager for the medication schedule model.'''
+    """Manager for the medication schedule model."""
+
     def get_by_natural_key(self, name):
         """
         Retrieve a MedicationSchedule instance by its name.
-        
+
         Parameters:
             name (str): The name of the medication schedule to retrieve.
-        
+
         Returns:
             MedicationSchedule: The matching medication schedule instance.
         """
         return self.get(name=name)
-    
+
+
 class MedicationSchedule(models.Model):
-    '''Model representing a medication schedule.'''
-    name = models.CharField(max_length=255, unique=True) 
+    """Model representing a medication schedule."""
+
+    name = models.CharField(max_length=255, unique=True)
     description = models.TextField(blank=True, null=True)
     medication = models.ForeignKey("Medication", on_delete=models.CASCADE)
     unit = models.ForeignKey("Unit", on_delete=models.CASCADE)
     therapy_duration_d = models.FloatField(blank=True, null=True)
     dose = models.FloatField()
     intake_times = models.ManyToManyField(
-        "MedicationIntakeTime", 
+        "MedicationIntakeTime",
     )
 
     objects = MedicationScheduleManager()
 
+    if TYPE_CHECKING:
+        unit: models.ForeignKey["Unit"]
+        medication: models.ForeignKey["Medication"]
+        intake_times = cast("models.manager.RelatedManager[MedicationIntakeTime]", intake_times)
+
     def natural_key(self):
-        '''Return the natural key for the medication schedule.'''
+        """Return the natural key for the medication schedule."""
         return (self.name,)
-    
+
     def __str__(self):
         return str(self.name)
-    
+
     def get_intake_times(self) -> List["MedicationIntakeTime"]:
-        '''Return a list of all intake times for this medication schedule.'''
-        return [_ for _ in self.intake_times.all()] # type: ignore # pylint: disable=E1101
-    
+        """Return a list of all intake times for this medication schedule."""
+        return [_ for _ in self.intake_times.all()]

endoreg_db/models/medical/organ/__init__.py

@@ -1,35 +1,38 @@
 """Module for Organ models."""
+
 from django.db import models
 
+
 class OrganManager(models.Manager):
     """Manager for Organ model."""
 
     def get_by_natural_key(self, name):
         """Retrieve an Organ by its natural key."""
         return self.get(name=name)
-    
+
     def all_names(self):
         """Return a list of all organ names."""
-        return list(self.all().values_list('name', flat=True))
-    
+        return list(self.all().values_list("name", flat=True))
+
+
 class Organ(models.Model):
     """Model representing an organ."""
-    
-    name = models.CharField(max_length=100, unique=True) 
+
+    name = models.CharField(max_length=100, unique=True)
     description = models.TextField(blank=True, null=True)
 
     # Deprecated
-    location_choices = models.ManyToManyField(
-        'FindingClassificationChoice', 
-        blank=True, related_name='organs'
-    )
+    # location_choices = models.ManyToManyField(
+    #     'FindingClassificationChoice',
+    #     blank=True, related_name='organs'
+    # )
 
     objects = OrganManager()
-    
+
     def natural_key(self):
         """Return the natural key for the organ."""
         return (self.name,)
-    
+
     def __str__(self):
         """Return string representation of the organ."""
-        return str(self.name)
+        return str(self.name)

endoreg_db/models/medical/patient/medication_examples.py

@@ -1,12 +1,8 @@
 from endoreg_db.models import (
-    Patient,
-    PatientMedication,
-    PatientMedicationSchedule,
     Medication, 
     MedicationIndication, 
     MedicationIndicationType, 
-    MedicationIntakeTime, 
-    MedicationSchedule
+    MedicationIntakeTime
 )
 from endoreg_db.helpers.default_objects import generate_patient
 
@@ -32,7 +28,11 @@ daily_night = MedicationIntakeTime.dn()
 mi = MedicationIndication.objects.order_by('?').first()
 
 # Alternatively, we can use a specific indication type
-medication_indication_type = MedicationIndicationType.objects.filter(indication_type='thromboembolism-prevention-non_valvular_af').order_by('?').first()
+
+# FIXME MedicationIndicationType does not have a field named indication_type
+# It does have: id, medication_indications, name
+
+# medication_indication_type = MedicationIndicationType.objects.filter(indication_type='thromboembolism-prevention-non_valvular_af').order_by('?').first()
 
 patient = generate_patient()
 

endoreg_db/models/medical/patient/patient_disease.py

@@ -1,10 +1,12 @@
+from typing import TYPE_CHECKING, cast  # Added List
+
 from django.db import models
-from typing import TYPE_CHECKING # Added List
 
 if TYPE_CHECKING:
+    from endoreg_db.utils.links.requirement_link import RequirementLinks  # Added RequirementLinks
+
     from ...administration.person.patient.patient import Patient
     from ..disease import Disease, DiseaseClassificationChoice
-    from endoreg_db.utils.links.requirement_link import RequirementLinks # Added RequirementLinks
 
 
 class PatientDisease(models.Model):
@@ -14,14 +16,9 @@ class PatientDisease(models.Model):
     Links a patient to a disease type, optional classification choices, start/end dates,
     and stores associated subcategory values and numerical descriptors.
     """
-    patient = models.ForeignKey(
-        "Patient", on_delete=models.CASCADE,
-        related_name="diseases"
-    )
-    disease = models.ForeignKey(
-        "Disease", on_delete=models.CASCADE,
-        related_name="patient_diseases"
-    )
+
+    patient = models.ForeignKey("Patient", on_delete=models.CASCADE, related_name="diseases")
+    disease = models.ForeignKey("Disease", on_delete=models.CASCADE, related_name="patient_diseases")
     classification_choices = models.ManyToManyField("DiseaseClassificationChoice")
     start_date = models.DateField(blank=True, null=True)
     end_date = models.DateField(blank=True, null=True)
@@ -31,33 +28,33 @@ class PatientDisease(models.Model):
     last_update = models.DateTimeField(auto_now=True)
 
     if TYPE_CHECKING:
-        patient: "Patient"
-        disease: "Disease"
-        classification_choices: models.QuerySet["DiseaseClassificationChoice"]
+        patient: models.ForeignKey["Patient"]
+        disease: models.ForeignKey["Disease"]
+
+        classification_choices = cast(
+            "models.manager.RelatedManager[DiseaseClassificationChoice]",
+            classification_choices,
+        )
 
     def __str__(self):
         """Returns a string representation including the patient and disease name."""
         return f"{self.patient} - {self.disease}"
-    
+
     @property
     def links(self) -> "RequirementLinks":
-        from endoreg_db.utils.links.requirement_link import RequirementLinks # Added RequirementLinks
+        from endoreg_db.utils.links.requirement_link import RequirementLinks  # Added RequirementLinks
 
         """
         Aggregates and returns related model instances relevant for requirement evaluation
         as a RequirementLinks object.
         """
-        links_data = {
-            "patient_diseases": [self],
-            "diseases": [],
-            "disease_classification_choices": list(self.classification_choices.all())
-        }
+        links_data = {"patient_diseases": [self], "diseases": [], "disease_classification_choices": list(self.classification_choices.all())}
         if self.disease:
             links_data["diseases"].append(self.disease)
-        
+
         return RequirementLinks(**links_data)
 
     class Meta:
         # unique_together = ('patient', 'disease', 'start_date')
-        verbose_name = 'Patient Disease'
-        verbose_name_plural = 'Patient Diseases'
+        verbose_name = "Patient Disease"
+        verbose_name_plural = "Patient Diseases"

endoreg_db/models/medical/patient/patient_event.py

@@ -1,10 +1,12 @@
-from django.db import models
 from typing import TYPE_CHECKING
 
+from django.db import models
+
 if TYPE_CHECKING:
     from ...administration.person.patient.patient import Patient
     from ..event import Event, EventClassificationChoice
 
+
 class PatientEvent(models.Model):
     """
     Represents a specific event occurrence for a patient, potentially with classification details.
@@ -12,26 +14,24 @@ class PatientEvent(models.Model):
     Links a patient to an event type, dates, description, and optional classification choices,
     subcategories, and numerical descriptors.
     """
-    patient:models.ForeignKey["Patient"] = models.ForeignKey(
-        "Patient", on_delete=models.CASCADE,
-        related_name="events"
-    )
-    event:models.ForeignKey["Event"] = models.ForeignKey(
-        "Event", on_delete=models.CASCADE,
-        related_name="patient_events"
-    )
+
+    patient: models.ForeignKey["Patient"] = models.ForeignKey("Patient", on_delete=models.CASCADE, related_name="events")
+    event: models.ForeignKey["Event"] = models.ForeignKey("Event", on_delete=models.CASCADE, related_name="patient_events")
     date_start = models.DateField()
     date_end = models.DateField(blank=True, null=True)
     description = models.TextField(blank=True, null=True)
-    classification_choice:models.ForeignKey["EventClassificationChoice"] = models.ForeignKey(
-        "EventClassificationChoice", on_delete=models.CASCADE, blank=True, null=True
-    )
+    classification_choice = models.ForeignKey("EventClassificationChoice", on_delete=models.CASCADE, blank=True, null=True)
 
     subcategories = models.JSONField(default=dict)
     numerical_descriptors = models.JSONField(default=dict)
 
     last_update = models.DateTimeField(auto_now=True)
 
+    if TYPE_CHECKING:
+        patient: models.ForeignKey["Patient"]
+        event: models.ForeignKey["Event"]
+        classification_choice: models.ForeignKey["EventClassificationChoice|None"]
+
     @property
     def links(self):
         """
@@ -39,12 +39,9 @@ class PatientEvent(models.Model):
         Currently, it only includes the patient and event.
         """
         from endoreg_db.utils.links.requirement_link import RequirementLinks
-        return RequirementLinks(
-            patient_events=[self],
-            patients=[self.patient],
-            events=[self.event]
-        )
-        
+
+        return RequirementLinks(patient_events=[self], events=[self.event])
+
     @property
     def date(self):
         """
@@ -57,19 +54,19 @@ class PatientEvent(models.Model):
         Returns a string representation of the event's start date and name.
         """
         return str(self.date_start) + ": " + self.event.name
-    
+
     def set_subcategories_from_classification_choice(self):
         """Copies subcategory definitions from the linked classification choice."""
         if self.classification_choice:
             self.subcategories = self.classification_choice.subcategories
             self.save()
-        
+
         return self.subcategories
-    
+
     def set_numerical_descriptors_from_classification_choice(self):
         """Copies numerical descriptor definitions from the linked classification choice."""
         if self.classification_choice:
             self.numerical_descriptors = self.classification_choice.numerical_descriptors
             self.save()
-        
+
         return self.numerical_descriptors