endoreg-db 0.5.3__py3-none-any.whl → 0.6.1__py3-none-any.whl

endoreg_db/models/persons/patient/patient.py

@@ -1,13 +1,18 @@
 from ..person import Person
 from django import forms
 from django.forms import DateInput
-from rest_framework import serializers
-from ...patient_examination import PatientExamination
+from ...patient import PatientExamination
 from ...data_file import ReportFile
 from django.db import models
 from faker import Faker
 import random
 from datetime import datetime
+from icecream import ic
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from endoreg_db.models import Center, Gender
+
 
 class Patient(Person):
     """
@@ -22,33 +27,196 @@ class Patient(Person):
         phone (str): The phone number of the patient.
 
     """
-    center = models.ForeignKey("Center", on_delete=models.CASCADE, blank=True, null=True)
-    
+
+    # -----gc-08-dev--changings---
+    first_name = models.CharField(max_length=100)
+    last_name = models.CharField(max_length=100)
+    dob = models.DateField(null=True, blank=True)
+    gender = models.ForeignKey(
+        "Gender", on_delete=models.SET_NULL, null=True, blank=True
+    )
+    center = models.ForeignKey(
+        "Center", on_delete=models.SET_NULL, null=True, blank=True
+    )
+    patient_hash = models.CharField(max_length=255, blank=True, null=True)
 
     def __str__(self):
-        return self.first_name + " " + self.last_name + " (" + str(self.dob) + ")"
-    
-    def get_unmatched_report_files(self): #field: self.report_files; filter: report_file.patient_examination = None
-        '''Returns all report files for this patient that are not matched to a patient examination.'''
+        return f"{self.first_name} {self.last_name} ({self.dob})"
+
+    @classmethod
+    def get_or_create_pseudo_patient_by_hash(
+        cls,
+        patient_hash: str,
+        center: "Center" = None,
+        gender: "Gender" = None,
+        birth_month: int = None,
+        birth_year: int = None,
+    ):
+        from endoreg_db.utils import random_day_by_year, create_mock_patient_name
+
+        created = False
+
+        existing_pathient = cls.objects.filter(patient_hash=patient_hash).first()
+        if existing_pathient:
+            ic(f"Patient with hash {patient_hash} already exists")
+            ic(f"Returning existing patient: {existing_pathient}")
+            return existing_pathient, created
+
+        # If no patient with the given hash exists, create a new pseudo patient
+        assert center, "Center must be provided to create a new pseudo patient"
+        assert gender, "Gender must be provided to create a new pseudo patient"
+        assert birth_month, (
+            "Birth month must be provided to create a new pseudo patient"
+        )
+        assert birth_year, "Birth year must be provided to create a new pseudo patient"
+
+        pseudo_dob = random_day_by_year(birth_year)
+        gender_name = gender.name
+        first_name, last_name = create_mock_patient_name(gender_name)
+
+        ic(f"Creating pseudo patient with hash {patient_hash}")
+        ic(f"Generated name: {first_name} {last_name}")
+
+        patient = cls.objects.create(
+            first_name=first_name,
+            last_name=last_name,
+            dob=pseudo_dob,
+            patient_hash=patient_hash,
+            is_real_person=False,
+        )
+
+        patient.save()
+        created = True
+
+        return patient, created
+
+    def export_patient_examinations(self):
+        """
+        Get all associated PatientExaminations, ReportFiles, and Videos for the patient.
+        """
+        from endoreg_db.models import PatientExamination, ReportFile, Video
+
+        patient_examinations = PatientExamination.objects.filter(patient=self)
+        report_files, videos = [], []
+        for patient_examination in patient_examinations:
+            rr = patient_examination.reportfile_set.all()
+            vv = patient_examination.videos.all()
+
+            report_files.extend(rr)
+            videos.extend(vv)
+
+        return patient_examinations, report_files, videos
+
+    def get_dob(self) -> datetime.date:
+        dob: datetime.date = self.dob
+        return dob
+
+    def get_unmatched_report_files(
+        self,
+    ):  # field: self.report_files; filter: report_file.patient_examination = None
+        """Returns all report files for this patient that are not matched to a patient examination."""
 
         return self.reportfile_set.filter(patient_examination=None)
 
-    def get_unmatched_video_files(self): #field: self.videos; filter: video.patient_examination = None
-        '''Returns all video files for this patient that are not matched to a patient examination.'''
+    def get_unmatched_video_files(
+        self,
+    ):  # field: self.videos; filter: video.patient_examination = None
+        """Returns all video files for this patient that are not matched to a patient examination."""
         return self.videos.filter(patient_examination=None)
 
-    def get_patient_examinations(self): #field: self.patient_examinations
-        '''Returns all patient examinations for this patient ordered by date (most recent is first).'''
-        return self.patient_examinations.order_by('-date')
-    
-    def create_examination_by_report_file(self, report_file:ReportFile):
-        '''Creates a patient examination for this patient based on the given report file.'''
+    def get_patient_examinations(self):  # field: self.patient_examinations
+        """Returns all patient examinations for this patient ordered by date (most recent is first)."""
+        return self.patient_examinations.order_by("-date")
+
+    def create_examination(
+        self,
+        examination_name_str: str = None,
+        date_start: datetime = None,
+        date_end: datetime = None,
+    ):
+        """Creates a patient examination for this patient."""
+
+        if examination_name_str:
+            from endoreg_db.models import Examination
+
+            examination = Examination.objects.get(name=examination_name_str)
+            patient_examination = PatientExamination(
+                patient=self,
+                examination=examination,
+                date_start=date_start,
+                date_end=date_end,
+            )
+
+        else:
+            patient_examination = PatientExamination(
+                patient=self, date_start=date_start, date_end=date_end
+            )
+
+        patient_examination.save()
+
+        return patient_examination
+
+    def create_examination_by_indication(
+        self, indication, date_start: datetime = None, date_end: datetime = None
+    ):
+        from endoreg_db.models import (
+            ExaminationIndication,
+            Examination,
+            PatientExaminationIndication,
+        )
+
+        assert isinstance(indication, ExaminationIndication)
+
+        examination = indication.get_examination()
+
+        assert isinstance(examination, Examination)
+
+        patient_examination = PatientExamination.objects.create(
+            patient=self,
+            examination=examination,
+            date_start=date_start,
+            date_end=date_end,
+        )
+
+        patient_examination.save()
+
+        patient_examination_indication = PatientExaminationIndication.objects.create(
+            patient_examination=patient_examination, examination_indication=indication
+        )
+        patient_examination_indication.save()
+
+        return patient_examination, patient_examination_indication
+
+    def create_event(
+        self,
+        event_name_str: str,
+        date_start: datetime = None,
+        date_end: datetime = None,
+        description: str = None,
+    ):
+        from endoreg_db.models import Event, PatientEvent
+
+        event = Event.objects.get(name=event_name_str)
+
+        if not date_start:
+            date_start = datetime.now()
+
+        patient_event = PatientEvent.objects.create(
+            patient=self,
+            event=event,
+            date_start=date_start,
+        )
+
+        return patient_event
+
+    def create_examination_by_report_file(self, report_file: ReportFile):
+        """Creates a patient examination for this patient based on the given report file."""
         patient_examination = PatientExamination(patient=self, report_file=report_file)
         patient_examination.save()
         return patient_examination
-    
+
     @classmethod
-    def get_random_gender(self, p_male=0.5, p_female=0.5):
+    def get_random_gender(cls, p_male=0.5, p_female=0.5):
         """
         Get a Gender object by name (male, female) from the database with given probability.
 
@@ -57,33 +225,28 @@ class Patient(Person):
         :return: Gender object selected based on given probabilities.
         """
         from endoreg_db.models import Gender
-        
+
         # Extract names and probabilities
         gender_names = ["male", "female"]
-        probabilities = [0.5, 0.5]
-        
+        probabilities = [p_male, p_female]
+
         # Debug: print the names and probabilities
-        print(f"Gender names: {gender_names}")
-        print(f"Probabilities: {probabilities}")
-        
+        # print(f"Gender names: {gender_names}")
+        # print(f"Probabilities: {probabilities}")
+
         # Select a gender based on the given probabilities
         selected_gender = random.choices(gender_names, probabilities)[0]
         # Debug: print the selected gender
-        print(f"Selected gender: {selected_gender}")
-        
+        # print(f"Selected gender: {selected_gender}")
+
         # Fetch the corresponding Gender object from the database
         gender_obj = Gender.objects.get(name=selected_gender)
-        
-        return gender_obj
 
+        return gender_obj
 
     @classmethod
-    def get_random_age(self, 
-            min_age = 55,
-            max_age = 90,
-            mean_age = 65,
-            std_age = 10,
-            distribution = "normal"
+    def get_random_age(
+        cls, min_age=55, max_age=90, mean_age=65, std_age=10, distribution="normal"
     ):
         """
         Get a random age based on the given distribution.
@@ -99,11 +262,11 @@ class Patient(Person):
             age = int(random.normalvariate(mean_age, std_age))
         else:
             age = int(random.uniform(min_age, max_age))
-        
+
         return age
-    
+
     @classmethod
-    def get_dob_from_age(self, age, current_date=None):
+    def get_dob_from_age(cls, age, current_date=None):
         """
         Get a date of birth based on the given age and current date.
 
@@ -119,24 +282,24 @@ class Patient(Person):
         # randomize the day and month by adding a random number of days (0-364) to the date
 
         return dob
-        
+
     @classmethod
-    def get_random_name_for_gender(self, gender_obj, locale="de_DE"):
+    def get_random_name_for_gender(cls, gender_obj, locale="de_DE"):
         gender = gender_obj.name
         fake = Faker(locale)
-        
+
         if gender == "male":
             first_name = fake.first_name_male()
             last_name = fake.last_name_male()
 
-        else: 
+        else:
             first_name = fake.first_name_female()
             last_name = fake.last_name_female()
 
         return last_name, first_name
-    
+
     @classmethod
-    def create_generic(self, center="gplay_case_generator"):
+    def create_generic(cls, center="gplay_case_generator"):
         """
         Create a generic patient with random attributes.
 
@@ -144,6 +307,7 @@ class Patient(Person):
         :return: The created patient.
         """
         from endoreg_db.models import Center
+
         gender = Patient.get_random_gender()
         last_name, first_name = Patient.get_random_name_for_gender(gender)
 
@@ -155,7 +319,8 @@ class Patient(Person):
         patient = Patient.objects.create(
             first_name=first_name,
             last_name=last_name,
-            dob=dob
+            dob=dob,
+            gender=gender,
         )
         patient.save()
         return patient
@@ -169,7 +334,11 @@ class Patient(Person):
         # calculate correct age based on current date including day and month
         current_date = datetime.now()
         dob = self.dob
-        age = current_date.year - dob.year - ((current_date.month, current_date.day) < (dob.month, dob.day))
+        age = (
+            current_date.year
+            - dob.year
+            - ((current_date.month, current_date.day) < (dob.month, dob.day))
+        )
         return age
 
     def create_lab_sample(self, sample_type="generic", date=None, save=True):
@@ -182,19 +351,22 @@ class Patient(Person):
         :return: The created lab sample.
         """
         from endoreg_db.models import PatientLabSample, PatientLabSampleType
+
         if date is None:
             date = datetime.now()
 
         if isinstance(sample_type, str):
             sample_type = PatientLabSampleType.objects.get(name=sample_type)
-            assert sample_type is not None, f"Sample type with name '{sample_type}' not found."#
+            assert sample_type is not None, (
+                f"Sample type with name '{sample_type}' not found."
+            )  #
         elif not isinstance(sample_type, PatientLabSampleType):
-            raise ValueError("Sample type must be either a string or a PatientLabSampleType object.")
-        
+            raise ValueError(
+                "Sample type must be either a string or a PatientLabSampleType object."
+            )
+
         patient_lab_sample = PatientLabSample.objects.create(
-            patient=self,
-            sample_type=sample_type,
-            date=date
+            patient=self, sample_type=sample_type, date=date
         )
 
         if save:
@@ -202,15 +374,16 @@ class Patient(Person):
 
         return patient_lab_sample
 
+
 class PatientForm(forms.ModelForm):
     class Meta:
         model = Patient
-        fields = '__all__'
+        fields = "__all__"
         widgets = {
-            'dob': DateInput(attrs={'type': 'date'}),
+            "dob": DateInput(attrs={"type": "date"}),
         }
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         for field in self.fields.values():
-            field.widget.attrs['class'] = 'form-control'
+            field.widget.attrs["class"] = "form-control"

endoreg_db/models/persons/patient/patient_disease.py

@@ -8,9 +8,15 @@ class PatientDisease(models.Model):
     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)
 
     def __str__(self):
         return f"{self.patient} - {self.disease}"
     
+    class Meta:
+        # unique_together = ('patient', 'disease', 'start_date')
+        verbose_name = 'Patient Disease'
+        verbose_name_plural = 'Patient Diseases'

endoreg_db/models/persons/patient/patient_event.py

@@ -15,8 +15,38 @@ class PatientEvent(models.Model):
     date_start = models.DateField()
     date_end = models.DateField(blank=True, null=True)
     description = models.TextField(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)
     
     def __str__(self):
-        return str(self.date_start) + ": " + self.event
+        return str(self.date_start) + ": " + self.event.name
+    
+    def set_subcategories_from_classification_choice(self):
+        """
+        Sets the subcategories for this event from the classification choice.
+        """
+        from endoreg_db.models import EventClassificationChoice
+        if self.classification_choice:
+            self.classification_choice:EventClassificationChoice
+            self.subcategories = self.classification_choice.subcategories
+            self.save()
+        
+        return self.subcategories
+    
+    def set_numerical_descriptors_from_classification_choice(self):
+        """
+        Sets the numerical descriptors for this event from the classification choice.
+        """
+        from endoreg_db.models import EventClassificationChoice
+        if self.classification_choice:
+            self.classification_choice:EventClassificationChoice
+            self.numerical_descriptors = self.classification_choice.numerical_descriptors
+            self.save()
+        
+        return self.numerical_descriptors

endoreg_db/models/persons/patient/patient_examination_indication.py

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

endoreg_db/models/persons/patient/patient_lab_sample.py

@@ -58,10 +58,12 @@ class PatientLabSample(models.Model):
     date = models.DateTimeField()
 
     def __str__(self):
-        return f"{self.patient} - {self.sample_type} - {self.date} ()"
+
+        formatted_datetime = self.date.strftime('%Y-%m-%d %H:%M')
+        return f"{self.patient} - {self.sample_type} - {formatted_datetime} ()"
     
     def get_values(self):
-        return self.values
+        return self.values.all()
     
     @classmethod
     def create_by_patient(cls, patient=None, sample_type=None, date=None, save = True):

endoreg_db/models/persons/patient/patient_lab_value.py

@@ -30,7 +30,11 @@ class PatientLabValue(models.Model):
     unit = models.ForeignKey('Unit', on_delete=models.CASCADE, blank=True, null=True)
 
     @classmethod
-    def create_lab_value_by_sample(cls, sample=None, lab_value_name=None, value=None, value_str=None, unit=None):
+    def create_lab_value_by_sample(
+        cls, sample=None, lab_value_name=None, 
+        value=None, value_str=None, 
+        unit=None
+    ):
         from endoreg_db.models import LabValue
         patient = sample.patient
         lab_value = LabValue.objects.get(name=lab_value_name)
@@ -51,10 +55,26 @@ class PatientLabValue(models.Model):
         return pat_lab_val
 
     def __str__(self):
-        _str = f'{self.lab_value} - {self.value} {self.unit} ({self.datetime})'
-        print(_str)
+        formatted_datetime = self.datetime.strftime('%Y-%m-%d %H:%M')
+        # normal_range = self.get_normal_range()
+        norm_range_string = f'[{self.normal_range.get("min", "")} - {self.normal_range.get("max", "")}]'
+        _str = f'{self.lab_value} - {self.value} {self.unit} - {norm_range_string} ({formatted_datetime})'
         return _str
     
+    def get_normal_range(self):
+        from endoreg_db.models import LabValue, Patient
+        lab_value:LabValue = self.lab_value
+        patient:Patient = self.patient
+
+        age = patient.age()
+        gender = patient.gender
+
+        normal_range_dict = lab_value.get_normal_range(
+            age,gender
+        )
+        return normal_range_dict
+
+    
     def set_min_norm_value(self, value, save = True):
         self.normal_range["min"] = value
         if save:
@@ -66,13 +86,11 @@ class PatientLabValue(models.Model):
             self.save()
 
     def set_norm_values_from_default(self):
-        age = self.patient.age()
-        gender = self.patient.gender
-        min_value, max_value = self.lab_value.get_normal_range(age=age, gender=gender)
-        self.set_min_norm_value(min_value, save = False)
-        self.set_max_norm_value(max_value, save = False)
-        self.save()
 
+        normal_range_dict = self.get_normal_range()
+        self.set_min_norm_value(normal_range_dict["min"], save = False)
+        self.set_max_norm_value(normal_range_dict["max"], save = False)
+        self.save()
 
     def set_unit_from_default(self):
         self.unit = self.lab_value.default_unit
@@ -109,8 +127,8 @@ class PatientLabValue(models.Model):
 
         patient:Patient = self.patient
 
-        dob = patient.dob
-        gender:Gender = patient.gender
+        dob = patient.dob #TODO: age specific norm values
+        gender:Gender = patient.gender # TODO: gender specific norm values
         lab_value:LabValue = self.lab_value
 
         assert self.lab_value, "Lab value must be set to set value by distribution"
@@ -121,7 +139,7 @@ class PatientLabValue(models.Model):
 
             if not distribution:
                 warnings.warn(
-                    "No distribution set for lab value, assuming uniform numeric distribution based on normal values"
+                    f"No distribution set for lab value {lab_value}, assuming uniform numeric distribution based on normal values"
                 )
 
                 if not self.normal_range.get("min", None) or not self.normal_range.get("max", None):
@@ -133,12 +151,12 @@ class PatientLabValue(models.Model):
                 _name = "auto-" + self.lab_value.name + "-distribution-default-uniform" 
                 distribution = NumericValueDistribution(
                     name = _name,
-                    min_value = _min,
-                    max_value = _max,
+                    min_descriptor = _min,
+                    max_max_desciptor = _max,
                     distribution_type = "uniform"
                 )
 
-                value = distribution.generate_value()
+                value = distribution.generate_value(lab_value=lab_value)
                 self.value = value
                 if save:
                     self.save()
@@ -153,7 +171,10 @@ class PatientLabValue(models.Model):
             return value
         
         elif isinstance(distribution, NumericValueDistribution):
-            value = distribution.generate_value()
+            value = distribution.generate_value(
+                lab_value=lab_value,
+                patient=patient
+            )
             self.value = value
             if save:
                 self.save()

endoreg_db/models/persons/patient/patient_medication.py

@@ -8,11 +8,25 @@ class PatientMedication(models.Model):
         related_name="patient_medications", null=True
     )
 
-    medication_schedules = models.ManyToManyField(
-        'MedicationSchedule'
+    medication = models.ForeignKey(
+        'Medication', on_delete=models.CASCADE,
+        blank=True,
+        related_name='patient_medications'
+    )
+
+    intake_times = models.ManyToManyField(
+        'MedicationIntakeTime', 
+        related_name='patient_medications',
+        blank=True,
+    )
+
+    unit = models.ForeignKey(
+        'Unit', on_delete=models.CASCADE,
+        null=True, blank=True
+    )
+    dosage = models.JSONField(
+        null=True, blank=True
     )
-    unit = models.ForeignKey('Unit', on_delete=models.CASCADE)
-    dosage = models.JSONField()
     active = models.BooleanField(default=True)
 
     objects = models.Manager()
@@ -27,18 +41,19 @@ class PatientMedication(models.Model):
         medication_indication: MedicationIndication
         patient_medication = cls.objects.create(patient=patient, medication_indication=medication_indication)
         patient_medication.save()
-        patient_medication.set_schedules_from_indication()
         
         return patient_medication
 
-    def set_schedules_from_indication(self):
-        schedules = self.medication_indication.medication_schedules.all()
-        self.medication_schedules.set(schedules)
-        self.save()
 
     def __str__(self):
-        indication = self.medication_indication
-        schedules = self.medication_schedules.all()
-        return f'{indication} - {schedules}'
+        intake_times = self.intake_times.all()
+        out = f"{self.medication} (Indication {self.medication_indication}) - "
+        out += f"{self.dosage} - {self.unit} - "
+
+
+        for intake_time in intake_times:
+            out += f"{intake_time} - "
+
+        return out