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

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()
 

endoreg_db/models/medical/patient/patient_examination_indication.py

@@ -1,22 +1,26 @@
-from django.db import models
 from typing import TYPE_CHECKING
 
+from django.db import models
+
 if TYPE_CHECKING:
-    from .patient_examination import PatientExamination
     from ..examination import (
         ExaminationIndication,
         ExaminationIndicationClassificationChoice,
     )
+    from .patient_examination import PatientExamination
+
+
 class PatientExaminationIndication(models.Model):
-    '''A model to store the indication for a patient examination.'''
-    patient_examination = models.ForeignKey('PatientExamination', on_delete=models.CASCADE, related_name='indications')
-    examination_indication = models.ForeignKey('ExaminationIndication', on_delete=models.CASCADE)
-    indication_choice = models.ForeignKey('ExaminationIndicationClassificationChoice', on_delete=models.CASCADE, blank=True, null=True)
+    """A model to store the indication for a patient examination."""
+
+    patient_examination = models.ForeignKey("PatientExamination", on_delete=models.CASCADE, related_name="indications")
+    examination_indication = models.ForeignKey("ExaminationIndication", on_delete=models.CASCADE)
+    indication_choice = models.ForeignKey("ExaminationIndicationClassificationChoice", on_delete=models.CASCADE, blank=True, null=True)
 
     if TYPE_CHECKING:
-        patient_examination: "PatientExamination"
-        examination_indication: "ExaminationIndication"
-        indication_choice: "ExaminationIndicationClassificationChoice"
+        patient_examination: models.ForeignKey["PatientExamination"]
+        examination_indication: models.ForeignKey["ExaminationIndication"]
+        indication_choice: models.ForeignKey["ExaminationIndicationClassificationChoice|None"]
 
     def __str__(self):
         return f"{self.patient_examination} - {self.examination_indication}"
@@ -26,19 +30,17 @@ class PatientExaminationIndication(models.Model):
         e = pe.examination
 
         return e
-    
+
     def get_patient_examination(self):
         pe = self.patient_examination
         return pe
-    
+
     def get_patient(self):
         pe = self.get_patient_examination()
         patient = pe.patient
         return patient
-    
-    def get_choices(self):
 
+    def get_choices(self):
         examination_indication = self.examination_indication
         choices = [_ for _ in examination_indication.get_choices()]
         return choices
-