endoreg-db 0.3.4__py3-none-any.whl → 0.3.5__py3-none-any.whl

endoreg_db/models/other/resource.py

@@ -0,0 +1,18 @@
+from django.db import models
+
+class ResourceManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+    
+class Resource(models.Model):
+    objects = ResourceManager()
+
+    name = models.CharField(max_length=255)
+    name_de = models.CharField(max_length=255, null=True)
+    name_en = models.CharField(max_length=255, null=True)
+
+    def natural_key(self):
+        return (self.name,)
+    
+    def __str__(self):
+        return self.name

endoreg_db/models/other/transport_route.py

@@ -0,0 +1,21 @@
+from django.db import models
+
+class TransportRouteManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+    
+class TransportRoute(models.Model):
+    objects = TransportRouteManager()
+
+    distance = models.FloatField()
+    name = models.CharField(max_length=255)
+    name_de = models.CharField(max_length=255, null=True)
+    name_en = models.CharField(max_length=255, null=True)
+    emission_factor = models.ForeignKey("EmissionFactor", on_delete=models.SET_NULL, null=True)
+    unit = models.ForeignKey("Unit", on_delete=models.SET_NULL, null=True)
+
+    def natural_key(self):
+        return (self.name,)
+    
+    def __str__(self):
+        return self.name

endoreg_db/models/other/waste.py

@@ -0,0 +1,20 @@
+from django.db import models
+
+class WasteManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+    
+class Waste(models.Model):
+    objects = WasteManager()
+
+    name = models.CharField(max_length=255)
+    name_de = models.CharField(max_length=255, null=True)
+    name_en = models.CharField(max_length=255, null=True)
+    # emission_factor = models.ForeignKey("EmissionFactor", on_delete=models.SET_NULL, null=True)
+    
+    def natural_key(self):
+        return (self.name,)
+    
+    def __str__(self):
+        return self.name
+    

endoreg_db/models/persons/__init__.py

@@ -1,6 +1,7 @@
+from .gender import Gender
 from .person import Person
-from .patient import Patient, PatientForm
+from .patient import *
 from .examiner import Examiner, ExaminerSerializer
 from .portal_user_information import PortalUserInfo, Profession
 from .first_name import FirstName
-from .last_name import LastName
+from .last_name import LastName

endoreg_db/models/persons/gender.py

@@ -0,0 +1,22 @@
+from django.db import models
+
+class GenderManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+    
+class Gender(models.Model):
+    """A class representing gender."""
+    objects = GenderManager()
+
+    name = models.CharField(max_length=255)
+    name_de = models.CharField(max_length=255, null=True)
+    name_en = models.CharField(max_length=255, null=True)
+    abbreviation = models.CharField(max_length=255, null=True)
+    description = models.TextField(blank=True, null=True)
+
+    def natural_key(self):
+        return (self.name,)
+    
+    def __str__(self):
+        return self.name
+

endoreg_db/models/persons/patient/__init__.py

@@ -0,0 +1,8 @@
+from .patient import Patient, PatientForm
+from .patient_event import PatientEvent
+from .patient_disease import PatientDisease
+from .patient_lab_sample import PatientLabSample, PatientLabSampleType
+from .patient_lab_value import PatientLabValue
+from .patient_medication import PatientMedication
+from .patient_medication_schedule import PatientMedicationSchedule
+from .case import *

endoreg_db/models/persons/patient/case/case.py

@@ -0,0 +1,30 @@
+from django.db import models
+
+class Case(models.Model):
+    """
+    A class representing a case.
+
+    Attributes:
+        name (str): The name of the case.
+        description (str): A description of the case.
+        case_template (CaseTemplate): The case template of the case.
+        patient (Patient): The patient of the case.
+        start_date (datetime): The start date of the case.
+        end_date (datetime): The end date of the case.
+        is_active (bool): A flag indicating whether the case is active.
+        is_closed (bool): A flag indicating whether the case is closed.
+        is_deleted (bool): A flag indicating whether the case is deleted.
+        created_at (datetime): The creation date of the case.
+        updated_at (datetime): The last update date of the case.
+
+    """
+    start_date = models.DateTimeField()
+    end_date = models.DateTimeField(null=True)
+    is_active = models.BooleanField(default=True)
+    is_closed = models.BooleanField(default=False)
+    is_deleted = models.BooleanField(default=False)
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+
+    def __str__(self):
+        return self.name

endoreg_db/models/persons/patient/patient.py

@@ -0,0 +1,216 @@
+from ..person import Person
+from django import forms
+from django.forms import DateInput
+from rest_framework import serializers
+from ...patient_examination import PatientExamination
+from ...data_file import ReportFile
+from django.db import models
+from faker import Faker
+import random
+from datetime import datetime
+
+class Patient(Person):
+    """
+    A class representing a patient.
+
+    Attributes inhereted from Person:
+        first_name (str): The first name of the patient.
+        last_name (str): The last name of the patient.
+        dob (datetime.date): The date of birth of the patient.
+        gender (Foreign Key): The gender of the patient.
+        email (str): The email address of the patient.
+        phone (str): The phone number of the patient.
+
+    """
+    center = models.ForeignKey("Center", on_delete=models.CASCADE, 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 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.'''
+        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.'''
+        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):
+        """
+        Get a Gender object by name (male, female) from the database with given probability.
+
+        :param p_male: Probability of selecting 'male' gender.
+        :param p_female: Probability of selecting 'female' gender.
+        :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]
+        
+        # Debug: print the names and 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}")
+        
+        # Fetch the corresponding Gender object from the database
+        gender_obj = Gender.objects.get(name=selected_gender)
+        
+        return gender_obj
+
+
+    @classmethod
+    def get_random_age(self, 
+            min_age = 55,
+            max_age = 90,
+            mean_age = 65,
+            std_age = 10,
+            distribution = "normal"
+    ):
+        """
+        Get a random age based on the given distribution.
+
+        :param min_age: Minimum age.
+        :param max_age: Maximum age.
+        :param mean_age: Mean age.
+        :param std_age: Standard deviation of the age.
+        :param distribution: Distribution of the age.
+        :return: Random age based on the given distribution.
+        """
+        if distribution == "normal":
+            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):
+        """
+        Get a date of birth based on the given age and current date.
+
+        :param age: Age of the patient.
+        :param current_date: Current date.
+        :return: Date of birth based on the given age and current date.
+        """
+        if current_date is None:
+            current_date = datetime.now()
+        dob = current_date.replace(year=current_date.year - age).date()
+
+        # TODO
+        # 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"):
+        gender = gender_obj.name
+        fake = Faker(locale)
+        
+        if gender == "male":
+            first_name = fake.first_name_male()
+            last_name = fake.last_name_male()
+
+        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"):
+        """
+        Create a generic patient with random attributes.
+
+        :param center: The center of the patient.
+        :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)
+
+        age = Patient.get_random_age()
+        dob = Patient.get_dob_from_age(age)
+
+        center = Center.objects.get(name=center)
+
+        patient = Patient.objects.create(
+            first_name=first_name,
+            last_name=last_name,
+            dob=dob
+        )
+        patient.save()
+        return patient
+
+    def age(self):
+        """
+        Get the age of the patient.
+
+        :return: The age of the patient.
+        """
+        # 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))
+        return age
+
+    def create_lab_sample(self, sample_type="generic", date=None, save=True):
+        """
+        Create a lab sample for this patient.
+
+        :param sample_type: The sample type. Should be either string of the sample types
+            name or the sample type object. If not set, the default sample type ("generic") is used.
+        :param date: The date of the lab sample.
+        :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."#
+        elif not isinstance(sample_type, PatientLabSampleType):
+            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
+        )
+
+        if save:
+            patient_lab_sample.save()
+
+        return patient_lab_sample
+
+class PatientForm(forms.ModelForm):
+    class Meta:
+        model = Patient
+        fields = '__all__'
+        widgets = {
+            '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'

endoreg_db/models/persons/patient/patient_disease.py

@@ -0,0 +1,16 @@
+from django.db import models
+
+
+
+class PatientDisease(models.Model):
+    patient = models.ForeignKey("Patient", on_delete=models.CASCADE)
+    disease = models.ForeignKey("Disease", on_delete=models.CASCADE)
+    classification_choices = models.ManyToManyField("DiseaseClassificationChoice")
+    start_date = models.DateField(blank=True, null=True)
+    end_date = models.DateField(blank=True, null=True)
+
+    last_update = models.DateTimeField(auto_now=True)
+
+    def __str__(self):
+        return f"{self.patient} - {self.disease}"
+    

endoreg_db/models/persons/patient/patient_event.py

@@ -0,0 +1,22 @@
+from django.db import models
+from .patient import Patient
+
+class PatientEvent(models.Model):
+    """
+    A class representing an event for a patient.
+
+    Attributes:
+        patient (Patient): The patient associated with this event.
+        date (datetime.date): The date of the event.
+        description (str): A description of the event.
+    """
+    patient = models.ForeignKey(Patient, on_delete=models.CASCADE)
+    event = models.ForeignKey("Event", on_delete=models.CASCADE)
+    date_start = models.DateField()
+    date_end = models.DateField(blank=True, null=True)
+    description = models.TextField(blank=True, null=True)
+
+    last_update = models.DateTimeField(auto_now=True)
+    
+    def __str__(self):
+        return str(self.date_start) + ": " + self.event

endoreg_db/models/persons/patient/patient_lab_sample.py

@@ -0,0 +1,106 @@
+from django.db import models
+
+DEFAULT_PATIENT_LAB_SAMPLE_TYPE_NAME = "generic"
+
+class PatientLabSampleTypeManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+    
+class PatientLabSampleType(models.Model):
+    """
+    A class representing a patient lab sample type.
+
+    Attributes:
+        name (str): The name of the patient lab sample type.
+        description (str): A description of the patient lab sample type.
+
+    """
+    name = models.CharField(max_length=255)
+    name_de = models.CharField(max_length=255, null=True)
+    name_en = models.CharField(max_length=255, null=True)
+    description = models.TextField(blank=True, null=True)
+
+    objects = PatientLabSampleTypeManager()
+
+    def natural_key(self):
+        return (self.name,)
+
+    def __str__(self):
+        return self.name
+    
+    @classmethod
+    def get_default_sample_type(cls):
+        """
+        Get the default patient lab sample type.
+
+        Returns:
+            PatientLabSampleType: The default patient lab sample type.
+
+        """
+        return cls.objects.get_or_create(name="default")[0]
+    
+from datetime import datetime as dt    
+from datetime import timezone
+class PatientLabSample(models.Model):
+    """
+    A class representing a patient lab sample.
+
+    Attributes:
+        patient (Patient): The patient to which the lab sample belongs.
+        sample_type (PatientLabSampleType): The type of the lab sample.
+        date (datetime): The date of the lab sample.
+        values (PatientLabValue; One2Many): The value of the lab sample.
+        unit (Unit): The unit of the lab sample.
+
+    """
+    patient = models.ForeignKey("Patient", on_delete=models.CASCADE, related_name="lab_samples")
+    sample_type = models.ForeignKey("PatientLabSampleType", on_delete=models.CASCADE)
+    date = models.DateTimeField()
+
+    def __str__(self):
+        return f"{self.patient} - {self.sample_type} - {self.date} ()"
+    
+    def get_values(self):
+        return self.values
+    
+    @classmethod
+    def create_by_patient(cls, patient=None, sample_type=None, date=None, save = True):
+        """
+        Create a new patient lab sample by patient.
+
+        Args:
+            patient (Patient): The patient to which the lab sample belongs.
+            sample_type (PatientLabSampleType): The type of the lab sample.
+            date (datetime): The date of the lab sample.
+
+        Returns:
+            PatientLabSample: The new patient lab sample.
+
+        """
+        from endoreg_db.models.persons.patient import Patient, PatientLabSampleType
+        from warnings import warn
+
+        if not patient:
+            warn("No patient given. Cannot create patient lab sample.")
+            return None
+        if not sample_type:
+            sample_type = PatientLabSampleType.get_default_sample_type()
+        else:
+            sample_type = PatientLabSampleType.objects.get(name=sample_type)
+        if not date:
+            date = dt.now(timezone.utc)
+
+        patient_lab_sample = cls.objects.create(
+            patient=patient,
+            sample_type=sample_type,
+            date=date
+        )
+
+        if save:
+            patient_lab_sample.save()
+
+        return patient_lab_sample
+
+
+    
+    

endoreg_db/models/persons/patient/patient_lab_value.py

@@ -0,0 +1,176 @@
+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):
+        _str = f'{self.lab_value} - {self.value} {self.unit} ({self.datetime})'
+        print(_str)
+        return _str
+    
+    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):
+        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()
+
+
+    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
+        gender:Gender = patient.gender
+        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(
+                    "No distribution set for 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_value = _min,
+                    max_value = _max,
+                    distribution_type = "uniform"
+                )
+
+                value = distribution.generate_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()
+            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()
+
+