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

endoreg_db/models/persons/patient/patient.py

@@ -1,216 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,106 +0,0 @@
-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

@@ -1,176 +0,0 @@
-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()
-
-

endoreg_db/models/persons/patient/patient_medication.py

@@ -1,44 +0,0 @@
-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_schedules = models.ManyToManyField(
-        'MedicationSchedule'
-    )
-    unit = models.ForeignKey('Unit', on_delete=models.CASCADE)
-    dosage = models.JSONField()
-    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()
-        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}'
-    
-    

endoreg_db/models/persons/patient/patient_medication_schedule.py

@@ -1,28 +0,0 @@
-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'
-    )
-
-    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

endoreg_db/models/persons/person.py

@@ -1,31 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,2 +0,0 @@
-from .image_classification import ImageClassificationPrediction
-from .video_prediction_meta import LegacyVideoPredictionMeta, VideoPredictionMeta