endoreg-db 0.8.6.4__py3-none-any.whl

endoreg_db/models/medical/organ/__init__.py

@@ -0,0 +1,35 @@
+"""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))
+    
+class Organ(models.Model):
+    """Model representing an organ."""
+    
+    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'
+    )
+
+    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)

endoreg_db/models/medical/patient/__init__.py

@@ -0,0 +1,56 @@
+from .patient_disease import (
+    PatientDisease,
+)
+
+from .patient_event import (
+    PatientEvent
+)
+
+# Examination
+from .patient_examination_indication import (
+    PatientExaminationIndication,
+)
+
+from .patient_examination import PatientExamination
+
+
+# Finding
+from .patient_finding import PatientFinding
+from .patient_finding_intervention import PatientFindingIntervention
+from .patient_finding_classification import PatientFindingClassification
+
+
+# Laboratory
+from .patient_lab_sample import PatientLabSample, PatientLabSampleType
+from .patient_lab_value import PatientLabValue
+
+# Medication
+from .patient_medication import PatientMedication
+from .patient_medication_schedule import PatientMedicationSchedule
+
+__all__ = [
+    # Disease
+    "PatientDisease",
+    
+    # Event
+    "PatientEvent",
+
+    # Examination
+    "PatientExaminationIndication",
+    "PatientExamination",
+
+    # Finding
+    "PatientFinding",
+    "PatientFindingClassification",
+    "PatientFindingIntervention",
+
+    # Laboratory
+    "PatientLabSample",
+    "PatientLabSampleType",
+    "PatientLabValue",
+
+    # Medication
+    "PatientMedication",
+    "PatientMedicationSchedule",
+
+]

endoreg_db/models/medical/patient/medication_examples.py

@@ -0,0 +1,38 @@
+from endoreg_db.models import (
+    Patient,
+    PatientMedication,
+    PatientMedicationSchedule,
+    Medication, 
+    MedicationIndication, 
+    MedicationIndicationType, 
+    MedicationIntakeTime, 
+    MedicationSchedule
+)
+from endoreg_db.helpers.default_objects import generate_patient
+
+available_medications = Medication.objects.all()
+
+# get common intake times
+common_intake_times = MedicationIntakeTime.objects.filter(
+    name__in=[
+        'daily-morning', 
+        'daily-noon', 
+        'daily-evening', 
+        'daily-night'
+    ]
+)
+
+# Alternatively, we can use classmethods
+daily_morning = MedicationIntakeTime.dm()
+daily_noon = MedicationIntakeTime.dno()
+daily_evening = MedicationIntakeTime.de()
+daily_night = MedicationIntakeTime.dn()
+
+# get random medication indication
+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()
+
+patient = generate_patient()
+

endoreg_db/models/medical/patient/patient_disease.py

@@ -0,0 +1,63 @@
+from django.db import models
+from typing import TYPE_CHECKING # Added List
+
+if TYPE_CHECKING:
+    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):
+    """
+    Represents a specific disease diagnosed for a patient, with optional classification and dates.
+
+    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"
+    )
+    classification_choices = models.ManyToManyField("DiseaseClassificationChoice")
+    start_date = models.DateField(blank=True, null=True)
+    end_date = models.DateField(blank=True, null=True)
+    numerical_descriptors = models.JSONField(default=dict)
+    subcategories = models.JSONField(default=dict)
+
+    last_update = models.DateTimeField(auto_now=True)
+
+    if TYPE_CHECKING:
+        patient: "Patient"
+        disease: "Disease"
+        classification_choices: models.QuerySet["DiseaseClassificationChoice"]
+
+    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
+
+        """
+        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())
+        }
+        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'

endoreg_db/models/medical/patient/patient_event.py

@@ -0,0 +1,75 @@
+from django.db import models
+from typing import TYPE_CHECKING
+
+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.
+
+    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"
+    )
+    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
+    )
+
+    subcategories = models.JSONField(default=dict)
+    numerical_descriptors = models.JSONField(default=dict)
+
+    last_update = models.DateTimeField(auto_now=True)
+
+    @property
+    def links(self):
+        """
+        Returns a dictionary of links related to this PatientEvent.
+        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]
+        )
+        
+    @property
+    def date(self):
+        """
+        Returns the start date of the event.
+        """
+        return self.date_start
+
+    def __str__(self):
+        """
+        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

@@ -0,0 +1,249 @@
+from django.db import models
+from typing import TYPE_CHECKING, List, Optional
+
+if TYPE_CHECKING: 
+    from ...administration.person.patient import Patient
+    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
+
+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]
+        "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]"
+        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"]
+
+    # report_files
+    class Meta:
+        verbose_name = "Patient Examination"
+        verbose_name_plural = "Patient Examinations"
+        ordering = ["patient", "examination", "date_start"]
+
+    @classmethod
+    def get_or_create_pseudo_patient_examination_by_hash(
+        cls,
+        patient_hash: str,
+        examination_hash: str,
+        examination_name: Optional[str] = None,
+    ):
+        from ...administration.person import Patient
+        from ..examination import Examination
+
+        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
+
+        patient, created = Patient.get_or_create_pseudo_patient_by_hash(patient_hash)
+        if examination_name is not None:
+            examination = Examination.objects.get(name=examination_name)
+        else:
+            examination = None
+
+        patient_examination = cls.objects.create(
+            patient=patient, examination=examination, hash=examination_hash
+        )
+
+        patient_examination.save()
+
+        created = True
+        return patient_examination, created
+
+    def __str__(self):
+        return f"{self.patient} - {self.examination} - {self.date_start}"
+
+    # override save method to make sure that the hash is always set,
+    # if none is existing generate an unique string
+
+    def generate_default_hash(self):
+        # create random hash
+        import random
+        import string
+
+        _hash = "DEFAULT_HASH_" + "".join(
+            random.choices(string.ascii_uppercase + string.digits, k=10)
+        )
+
+        return _hash
+
+    def save(self, *args, **kwargs):
+        if not self.hash:
+            self.hash = self.generate_default_hash()
+        super().save(*args, **kwargs)
+
+    def get_patient_age_at_examination(self) -> int:
+        """
+        Returns the patient's age at the time of the examination.
+        """
+        from ...administration.person.patient import Patient
+
+        patient: Patient = self.patient
+        dob = patient.get_dob()
+        date_start = self.date_start
+        return (date_start - dob).days // 365
+
+    def get_available_findings(self):
+        """
+        Returns all findings that are associated with the examination of this patient examination.
+        """
+
+        return self.examination.get_available_findings()
+
+    def get_findings(self) -> models.QuerySet["PatientFinding"]:
+        """
+        Returns all findings that are associated with this patient examination.
+        """
+
+        return self.patient_findings.all()
+
+    def get_indications(self) -> models.QuerySet["PatientExaminationIndication"]:
+        """
+        Returns all indications that are associated with this patient examination.
+        """
+        return self.indications.all()
+
+    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
+        ]
+        return choices
+
+    def get_or_create_patient_examination_by_id(self, pk: int) -> Optional["PatientExamination"]:
+        """Hilfsmethode zum Abrufen oder Erstellen einer PatientExamination nach ID"""
+        if not self.objects.filter(pk=pk).exists():
+            return None
+        else:
+            return self.objects.filter(pk=pk)
+
+    @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
+        - All interventions from those findings
+        - 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
+        
+        # Get all PatientExaminationIndication instances linked to this PatientExamination
+        patient_exam_indications = self.indications.all() 
+        
+        examination_indications_list: List["ExaminationIndication"] = []
+        indication_choices_list: List["ExaminationIndicationClassificationChoice"] = []
+
+        for pei in patient_exam_indications:
+            if pei.examination_indication:
+                examination_indications_list.append(pei.examination_indication)
+            if pei.indication_choice:
+                indication_choices_list.append(pei.indication_choice)
+
+        # Fetch all patient lab values associated with this patient examination's patient
+        patient_lab_values = []
+        if self.patient:
+            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  
+            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
+            examination_indications=examination_indications_list,
+            examination_indication_classification_choices=indication_choices_list,
+            patient_lab_values=patient_lab_values,
+            # Add findings-related data
+            patient_findings=patient_findings_list,
+            findings=findings_list,
+            finding_classifications=finding_classifications_list,
+            finding_classification_choices=finding_classification_choices_list,
+            finding_interventions=finding_interventions_list,
+        )
+
+    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
+
+        patient_finding = PatientFinding.objects.create(
+            patient_examination=self, finding=finding
+        )
+
+        patient_finding.save()
+
+        return patient_finding

endoreg_db/models/medical/patient/patient_examination_indication.py

@@ -0,0 +1,44 @@
+from django.db import models
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .patient_examination import PatientExamination
+    from ..examination import (
+        ExaminationIndication,
+        ExaminationIndicationClassificationChoice,
+    )
+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)
+
+    if TYPE_CHECKING:
+        patient_examination: "PatientExamination"
+        examination_indication: "ExaminationIndication"
+        indication_choice: "ExaminationIndicationClassificationChoice"
+
+    def __str__(self):
+        return f"{self.patient_examination} - {self.examination_indication}"
+
+    def get_examination(self):
+        pe = self.get_patient_examination()
+        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):
+
+        examination_indication = self.examination_indication
+        choices = [_ for _ in examination_indication.get_choices()]
+        return choices
+