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

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
 

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

endoreg_db/models/medical/patient/patient_examination.py

@@ -1,48 +1,51 @@
-from django.db import models
 from typing import TYPE_CHECKING, List, Optional
 
-if TYPE_CHECKING: 
+from django.db import models
+
+if TYPE_CHECKING:
+    from endoreg_db.utils.links.requirement_link import RequirementLinks
+
     from ...administration.person.patient import Patient
+    from ...media import AnonymExaminationReport, AnonymHistologyReport, RawPdfFile, VideoFile
+    from ..examination import Examination, ExaminationIndication, ExaminationIndicationClassificationChoice
     from ..finding import Finding
-    from .patient_finding import PatientFinding
-    from ..examination import Examination
-    from ...media import VideoFile, RawPdfFile, AnonymExaminationReport, AnonymHistologyReport
     from .patient_examination_indication import PatientExaminationIndication
-    from ..examination import ExaminationIndicationClassificationChoice, ExaminationIndication
-    from endoreg_db.utils.links.requirement_link import RequirementLinks
+    from .patient_finding import PatientFinding
+
 
 class PatientExamination(models.Model):
-    patient = models.ForeignKey(
-        "Patient", on_delete=models.CASCADE, related_name="patient_examinations"
-    )
-    examination = models.ForeignKey( # type: ignore[assignment]
-        "Examination", on_delete=models.CASCADE, null=True, blank=True
-    )
-    video = models.OneToOneField( # type: ignore[assignment]
+    patient = models.ForeignKey("Patient", on_delete=models.CASCADE, related_name="patient_examinations")
+    examination = models.ForeignKey("Examination", on_delete=models.CASCADE, null=True, blank=True)
+    video = models.OneToOneField(
         "VideoFile",
         on_delete=models.CASCADE,
         null=True,
         blank=True,
         related_name="patient_examination",
     )
-    
+
     objects = models.Manager()
-    
+
     date_start = models.DateField(null=True, blank=True)
     date_end = models.DateField(null=True, blank=True)
     hash = models.CharField(max_length=255, unique=True)
-    
 
     if TYPE_CHECKING:
         patient: "models.ForeignKey[Patient]"
-        examination: "models.ForeignKey[Examination]"
-        video: "models.OneToOneField[VideoFile]"
+        examination: "models.ForeignKey[Examination|None]"
+        video: "models.OneToOneField[VideoFile|None]"
         patient_findings: models.QuerySet["PatientFinding"]
         indications: models.QuerySet["PatientExaminationIndication"]
         raw_pdf_files: models.QuerySet["RawPdfFile"]
         anonymexaminationreport_set: models.QuerySet["AnonymExaminationReport"]
         anonymhistologyreport_set: models.QuerySet["AnonymHistologyReport"]
 
+    @property
+    def examination_safe(self):
+        if self.examination is None:
+            raise ValueError("Examination is not set for this PatientExamination.")
+        return self.examination
+
     # report_files
     class Meta:
         verbose_name = "Patient Examination"
@@ -61,12 +64,8 @@ class PatientExamination(models.Model):
 
         created = False
 
-        if PatientExamination.objects.filter(
-            patient__patient_hash=patient_hash, hash=examination_hash
-        ).exists():
-            return PatientExamination.objects.get(
-                patient__patient_hash=patient_hash, hash=examination_hash
-            ), created
+        if PatientExamination.objects.filter(patient__patient_hash=patient_hash, hash=examination_hash).exists():
+            return PatientExamination.objects.get(patient__patient_hash=patient_hash, hash=examination_hash), created
 
         patient, created = Patient.get_or_create_pseudo_patient_by_hash(patient_hash)
         if examination_name is not None:
@@ -74,9 +73,7 @@ class PatientExamination(models.Model):
         else:
             examination = None
 
-        patient_examination = cls.objects.create(
-            patient=patient, examination=examination, hash=examination_hash
-        )
+        patient_examination = cls.objects.create(patient=patient, examination=examination, hash=examination_hash)
 
         patient_examination.save()
 
@@ -94,9 +91,7 @@ class PatientExamination(models.Model):
         import random
         import string
 
-        _hash = "DEFAULT_HASH_" + "".join(
-            random.choices(string.ascii_uppercase + string.digits, k=10)
-        )
+        _hash = "DEFAULT_HASH_" + "".join(random.choices(string.ascii_uppercase + string.digits, k=10))
 
         return _hash
 
@@ -114,6 +109,8 @@ class PatientExamination(models.Model):
         patient: Patient = self.patient
         dob = patient.get_dob()
         date_start = self.date_start
+        assert dob is not None
+        assert date_start is not None
         return (date_start - dob).days // 365
 
     def get_available_findings(self):
@@ -121,6 +118,7 @@ class PatientExamination(models.Model):
         Returns all findings that are associated with the examination of this patient examination.
         """
 
+        assert self.examination is not None
         return self.examination.get_available_findings()
 
     def get_findings(self) -> models.QuerySet["PatientFinding"]:
@@ -139,13 +137,11 @@ class PatientExamination(models.Model):
     def get_indication_choices(self) -> List["ExaminationIndicationClassificationChoice"]:
         """
         Returns a list of indication choices associated with this patient examination.
-        
+
         Only includes indication choices that are not None.
         """
 
-        choices = [
-            _.indication_choice for _ in self.get_indications() if _.indication_choice is not None
-        ]
+        choices = [_.indication_choice for _ in self.get_indications() if _.indication_choice is not None]
         return choices
 
     def get_or_create_patient_examination_by_id(self, pk: int) -> Optional["PatientExamination"]:
@@ -153,14 +149,14 @@ class PatientExamination(models.Model):
         if not self.objects.filter(pk=pk).exists():
             return None
         else:
-            return self.objects.filter(pk=pk)
+            return self.objects.filter(pk=pk).first()
 
     @property
     def links(self) -> "RequirementLinks":
         """
         Aggregates and returns all related model instances relevant for requirement evaluation
         as a RequirementLinks object.
-        
+
         This includes:
         - All findings associated with this examination
         - All classifications and choices from those findings
@@ -168,12 +164,12 @@ class PatientExamination(models.Model):
         - Examination indications and their choices
         - Patient lab values
         """
-        from endoreg_db.utils.links.requirement_link import RequirementLinks
         from endoreg_db.models.medical.patient.patient_lab_value import PatientLabValue
-        
+        from endoreg_db.utils.links.requirement_link import RequirementLinks
+
         # Get all PatientExaminationIndication instances linked to this PatientExamination
-        patient_exam_indications = self.indications.all() 
-        
+        patient_exam_indications = self.indications.all()
+
         examination_indications_list: List["ExaminationIndication"] = []
         indication_choices_list: List["ExaminationIndicationClassificationChoice"] = []
 
@@ -189,37 +185,37 @@ class PatientExamination(models.Model):
             patient_lab_values = list(PatientLabValue.objects.filter(patient=self.patient))
 
         current_examination = [self.examination] if self.examination else []
-        
+
         # Now aggregate findings data from all PatientFinding instances
         findings_list = []
         finding_classifications_list = []
         finding_classification_choices_list = []
         finding_interventions_list = []
         patient_findings_list = []
-        
+
         for patient_finding in self.patient_findings.all():
             # Add the PatientFinding itself
             patient_findings_list.append(patient_finding)
-            
+
             # Add the base Finding
             if patient_finding.finding:
                 findings_list.append(patient_finding.finding)
-                
+
             # Add all active classifications and their choices from this PatientFinding
             for pf_classification in patient_finding.active_classifications:
                 if pf_classification.classification:
                     finding_classifications_list.append(pf_classification.classification)
                 if pf_classification.classification_choice:
                     finding_classification_choices_list.append(pf_classification.classification_choice)
-            
-            # Add all active interventions from this PatientFinding  
+
+            # Add all active interventions from this PatientFinding
             for pf_intervention in patient_finding.active_interventions:
                 if pf_intervention.intervention:
                     finding_interventions_list.append(pf_intervention.intervention)
 
         return RequirementLinks(
             patient_examinations=[self],  # Add the instance itself
-            examinations=current_examination, # Add the related Examination model
+            examinations=current_examination,  # Add the related Examination model
             examination_indications=examination_indications_list,
             examination_indication_classification_choices=indication_choices_list,
             patient_lab_values=patient_lab_values,
@@ -231,18 +227,16 @@ class PatientExamination(models.Model):
             finding_interventions=finding_interventions_list,
         )
 
-    def create_finding(self, finding:"Finding") -> "PatientFinding":
+    def create_finding(self, finding: "Finding") -> "PatientFinding":
         """
         Adds a finding to this patient examination.
         """
         from .patient_finding import PatientFinding
 
-        examination: Examination = self.examination
-        assert examination
+        examination = self.examination
+        assert examination is not None
 
-        patient_finding = PatientFinding.objects.create(
-            patient_examination=self, finding=finding
-        )
+        patient_finding = PatientFinding.objects.create(patient_examination=self, finding=finding)
 
         patient_finding.save()