endoreg-db 0.6.0__py3-none-any.whl → 0.6.2__py3-none-any.whl

endoreg_db/models/persons/patient/patient_lab_value.py

@@ -0,0 +1,197 @@
+from django.db import models
+
+class PatientLabValue(models.Model):
+    """
+    A class representing a patient lab value.
+
+    Attributes:
+        patient (Patient): The patient.
+        lab_value (LabValue): The lab value.
+        value (float): The value of the lab value.
+        date (datetime): The date of the lab value.
+    """
+    patient = models.ForeignKey('Patient', on_delete=models.CASCADE,
+                                related_name="lab_values", blank=True, null=True
+    )
+    lab_value = models.ForeignKey('LabValue', on_delete=models.CASCADE)
+    value = models.FloatField(blank=True, null=True)
+    value_str = models.CharField(max_length=255, blank=True, null=True)
+    sample = models.ForeignKey(
+        'PatientLabSample', on_delete=models.CASCADE, 
+        blank=True, null=True,
+        related_name='values'
+    )
+    datetime = models.DateTimeField(# if not set, use now
+        auto_now_add=True        
+    )
+    normal_range = models.JSONField(
+        default = dict
+    )
+    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
+    ):
+        from endoreg_db.models import LabValue
+        patient = sample.patient
+        lab_value = LabValue.objects.get(name=lab_value_name)
+        value = value
+        value_str = value_str
+
+        pat_lab_val = cls.objects.create(
+            patient = patient,
+            lab_value = lab_value,
+            value = value,
+            value_str = value_str,
+            sample = sample,
+            unit = unit,
+        )
+
+        pat_lab_val.save()
+
+        return pat_lab_val
+
+    def __str__(self):
+        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:
+            self.save()
+
+    def set_max_norm_value(self, value, save = True):
+        self.normal_range["max"] = value
+        if save:
+            self.save()
+
+    def set_norm_values_from_default(self):
+
+        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
+        self.save()
+
+    def get_value(self):
+        if self.value:
+            return self.value
+        else:
+            return self.value_str
+        
+    def get_value_field_name(self):
+        if self.value:
+            return "value"
+        else:
+            return "value_str"
+        
+    # customize save method so that if a numeric value exists, we round it to the precision of the lab value
+    def save(self, *args, **kwargs):
+        if self.value:
+            precision = self.lab_value.numeric_precision
+            self.value = round(self.value, precision)
+        super().save(*args, **kwargs)
+
+    def set_value_by_distribution(self, distribution=None, save = True):
+        from endoreg_db.models import (
+            Patient, LabValue, Gender,
+            DateValueDistribution,
+            SingleCategoricalValueDistribution,
+            NumericValueDistribution,
+            MultipleCategoricalValueDistribution,
+        ) 
+        import warnings  
+
+        patient:Patient = self.patient
+
+        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"
+        self.unit = self.lab_value.default_unit
+
+        if not distribution:
+            distribution = lab_value.get_default_default_distribution()
+
+            if not distribution:
+                warnings.warn(
+                    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):
+                    self.set_norm_values_from_default()
+
+                self.normal_range:dict
+                _min = self.normal_range.get("min", 0.0001)
+                _max = self.normal_range.get("max", 100)
+                _name = "auto-" + self.lab_value.name + "-distribution-default-uniform" 
+                distribution = NumericValueDistribution(
+                    name = _name,
+                    min_descriptor = _min,
+                    max_max_desciptor = _max,
+                    distribution_type = "uniform"
+                )
+
+                value = distribution.generate_value(lab_value=lab_value)
+                self.value = value
+                if save:
+                    self.save()
+                
+                return value
+
+        if isinstance(distribution, SingleCategoricalValueDistribution):
+            value = distribution.generate_value()
+            self.value_str = value
+            if save:
+                self.save()
+            return value
+        
+        elif isinstance(distribution, NumericValueDistribution):
+            value = distribution.generate_value(
+                lab_value=lab_value,
+                patient=patient
+            )
+            self.value = value
+            if save:
+                self.save()
+            return value
+        
+        elif isinstance(distribution, MultipleCategoricalValueDistribution):
+            value = distribution.generate_value()
+            self.value_str = value
+            if save:
+                self.save()
+            return value
+
+        elif isinstance(distribution, DateValueDistribution):
+            # raise not implemented error
+            value = distribution.generate_value()
+            self.value = value
+            if save:
+                self.save()
+
+

endoreg_db/models/persons/patient/patient_medication.py

@@ -0,0 +1,59 @@
+from django.db import models
+from django.utils.translation import gettext_lazy as _
+
+class PatientMedication(models.Model):
+    patient = models.ForeignKey("Patient", on_delete= models.CASCADE)
+    medication_indication = models.ForeignKey(
+        "MedicationIndication", on_delete=models.CASCADE,
+        related_name="patient_medications", null=True
+    )
+
+    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
+    )
+    active = models.BooleanField(default=True)
+
+    objects = models.Manager()
+
+    class Meta:
+        verbose_name = _('Patient Medication')
+        verbose_name_plural = _('Patient Medications')
+
+    @classmethod
+    def create_by_patient_and_indication(cls, patient, medication_indication):
+        from endoreg_db.models import MedicationIndication
+        medication_indication: MedicationIndication
+        patient_medication = cls.objects.create(patient=patient, medication_indication=medication_indication)
+        patient_medication.save()
+        
+        return patient_medication
+
+
+    def __str__(self):
+        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
+    
+    

endoreg_db/models/persons/patient/patient_medication_schedule.py

@@ -0,0 +1,88 @@
+from django.db import models
+
+class PatientMedicationSchedule(models.Model):
+    patient = models.ForeignKey("Patient", on_delete= models.CASCADE)
+    medication = models.ManyToManyField(
+        'PatientMedication', 
+        related_name='patient_medication_schedules',
+        blank=True
+    )
+
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+
+    def __str__(self):
+        return f'{self.patient} - {self.medication.all()}'
+    
+    @classmethod
+    def create_by_patient_and_indication_type(cls, patient, indication_type):
+        from endoreg_db.models import MedicationIndicationType, PatientMedication
+
+        medication_indication = MedicationIndicationType.get_random_indication_by_type(name=indication_type)
+
+        patient_medication_schedule = cls.objects.create(patient=patient)
+        patient_medication_schedule.save()
+
+        patient_medication = PatientMedication.create_by_patient_and_indication(patient, medication_indication)
+        patient_medication_schedule.medication.add(patient_medication)
+        patient_medication_schedule.save()
+
+        return patient_medication_schedule
+    
+    @classmethod
+    def create_by_patient_and_indication(cls, patient, medication_indication):
+        from endoreg_db.models import (
+            MedicationIndication, PatientMedication,
+            Patient
+        )
+
+        assert isinstance(medication_indication, MedicationIndication)
+        assert isinstance(patient, Patient)
+        patient_medication_schedule = cls.objects.create(patient=patient)
+        patient_medication_schedule.save()
+
+        patient_medication = PatientMedication.create_by_patient_and_indication(patient, medication_indication)
+        patient_medication_schedule.medication.add(patient_medication)
+        patient_medication_schedule.save()
+
+        return patient_medication_schedule
+    
+    def create_patient_medication_from_medication_schedule(
+            self,
+            medication_schedule,
+            medication_indication=None,
+            start_date=None,
+        ):
+        
+        from endoreg_db.models import MedicationSchedule, PatientMedication
+        from datetime import datetime as dt
+
+        assert isinstance(medication_schedule, MedicationSchedule)
+
+        if not start_date:
+            start_date = dt.now()
+
+        drug = medication_schedule.medication
+        unit = medication_schedule.unit
+        dosage = medication_schedule.dose
+        intake_times = medication_schedule.get_intake_times()
+
+        patient_medication = PatientMedication.objects.create(
+            patient=self.patient,
+            medication=drug,
+            medication_indication=medication_indication,
+            unit=unit,
+            dosage=dosage
+        )
+
+        patient_medication.intake_times.set(intake_times)
+        patient_medication.save()
+
+        self.medication.add(patient_medication)
+        self.save()  
+
+        return patient_medication
+    
+    
+    def get_patient_medication(self):
+        return self.medication.all()

endoreg_db/models/persons/person.py

@@ -0,0 +1,31 @@
+from abc import abstractmethod
+from django.db import models
+
+class Person(models.Model):
+    """
+    Abstract base class for a person.
+
+    Attributes:
+        first_name (str): The first name of the person.
+        last_name (str): The last name of the person.
+        dob (date): The date of birth of the person.
+        gender (str): The gender of the person.
+        email (str): The email address of the person.
+        phone (str): The phone number of the person.
+    """
+
+    first_name = models.CharField(max_length=255)
+    last_name = models.CharField(max_length=255)
+    dob = models.DateField("Date of Birth", blank=True, null=True)
+    gender = models.ForeignKey("Gender", on_delete=models.SET_NULL, null=True)
+    email = models.EmailField(max_length=255, blank=True, null=True)
+    phone = models.CharField(max_length=255, blank=True, null=True)
+    is_real_person = models.BooleanField(default=True)
+
+    @abstractmethod
+    def __str__(self):
+        pass
+
+    class Meta:
+        abstract = True
+

endoreg_db/models/persons/portal_user_information.py

@@ -0,0 +1,27 @@
+from django.db import models
+
+# models.py in your main app
+from django.contrib.auth.models import User
+
+class ProfessionManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+
+class Profession(models.Model):
+    objects = ProfessionManager()
+    name = models.CharField(max_length=100)
+    name_de = models.CharField(max_length=100, blank=True, null=True)
+    name_en = models.CharField(max_length=100, blank=True, null=True)
+    description = models.TextField(blank=True, null=True)
+
+    def __str__(self):
+        return self.name_de
+
+class PortalUserInfo(models.Model):
+    user = models.OneToOneField(User, on_delete=models.CASCADE)
+    profession = models.ForeignKey('Profession', on_delete=models.CASCADE, blank=True, null=True)
+    works_in_endoscopy = models.BooleanField(blank=True, null=True)
+    # Add other fields as needed
+
+    def __str__(self):
+        return self.user.username

endoreg_db/models/prediction/__init__.py

@@ -0,0 +1,8 @@
+from .image_classification import ImageClassificationPrediction
+from .video_prediction_meta import RawVideoPredictionMeta, VideoPredictionMeta
+
+__all__ = [
+    "ImageClassificationPrediction",
+    "RawVideoPredictionMeta",
+    "VideoPredictionMeta",
+]

endoreg_db/models/prediction/image_classification.py

@@ -0,0 +1,51 @@
+from django.db import models
+
+
+class ImageClassificationPrediction(models.Model):
+    """
+    A class representing an image classification prediction.
+
+    Attributes:
+        label (Label): The label of the prediction.
+        frame (Frame): The frame of the prediction.
+        confidence (float): The confidence of the prediction.
+        date_created (datetime): The date the prediction was created.
+
+    """
+
+    label = models.ForeignKey(
+        "Label",
+        on_delete=models.CASCADE,
+        related_name="image_classification_predictions",
+    )
+    frame = models.ForeignKey(
+        "Frame",
+        on_delete=models.CASCADE,
+        blank=True,
+        null=True,
+        related_name="image_classification_predictions",
+    )
+    value = models.BooleanField()
+    confidence = models.FloatField()
+    model_meta = models.ForeignKey(
+        "ModelMeta",
+        on_delete=models.CASCADE,
+        related_name="image_classification_predictions",
+    )
+    date_created = models.DateTimeField(auto_now_add=True)
+
+    class Meta:
+        unique_together = ("label", "frame", "model_meta")
+
+    def get_image_object(self):
+        """
+        Get the image of the prediction.
+        """
+        if self.frame:
+            return self.frame
+        elif self.legacy_frame:
+            return self.legacy_frame
+        elif self.legacy_image:
+            return self.legacy_image
+        else:
+            return None