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

endoreg_db/models/laboratory/lab_value.py

@@ -0,0 +1,102 @@
+from django.db import models
+import warnings
+
+LANG = "de"
+
+class LabValueManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+
+class LabValue(models.Model):
+    name = models.CharField(max_length=255, unique=True)
+    name_de = models.CharField(max_length=255, blank=True, null=True)
+    name_en = models.CharField(max_length=255, blank=True, null=True)
+    abbreviation = models.CharField(max_length=10, blank=True, null=True)
+    default_unit = models.ForeignKey('Unit', on_delete=models.CASCADE, blank=True, null=True)
+    numeric_precision = models.IntegerField(default=3)
+    default_single_categorical_value_distribution = models.ForeignKey(
+        'SingleCategoricalValueDistribution',
+        on_delete=models.CASCADE,
+        blank=True, null=True,
+        related_name='default_single_categorical_value_distribution'
+    )
+    default_numerical_value_distribution = models.ForeignKey(
+        'NumericValueDistribution',
+        on_delete=models.CASCADE,
+        blank=True, null=True,
+        related_name='default_numerical_value_distribution'
+    )
+    default_multiple_categorical_value_distribution = models.ForeignKey(
+        'MultipleCategoricalValueDistribution',
+        on_delete=models.CASCADE,
+        blank=True, null=True,
+        related_name='default_multiple_categorical_value_distribution'
+    )
+    default_date_value_distribution = models.ForeignKey(
+        'DateValueDistribution',
+        on_delete=models.CASCADE,
+        blank=True, null=True,
+        related_name='default_date_value_distribution'
+    )
+    default_normal_range = models.JSONField(blank=True, null=True)
+    normal_range_age_dependent = models.BooleanField(default=False)
+    normal_range_gender_dependent = models.BooleanField(default=False)
+    normal_range_special_case = models.BooleanField(default=False)
+    objects = LabValueManager()
+
+    def natural_key(self):
+        return (self.name,)
+
+    def __str__(self):
+        return self.name
+    
+    def get_default_default_distribution(self):
+        if self.default_single_categorical_value_distribution:
+            return self.default_single_categorical_value_distribution
+        elif self.default_numerical_value_distribution:
+            return self.default_numerical_value_distribution
+        elif self.default_multiple_categorical_value_distribution:
+            return self.default_multiple_categorical_value_distribution
+        elif self.default_date_value_distribution:
+            return self.default_date_value_distribution
+        else:
+            warnings.warn("No default distribution set for lab value")
+            return None
+    
+    def get_normal_range(self, age=None, gender=None):
+        age_dependent = self.normal_range_age_dependent
+        gender_dependent = self.normal_range_gender_dependent
+        special_case = self.normal_range_special_case
+
+        min_value = None
+        max_value = None
+
+        if not age_dependent and \
+        not gender_dependent and \
+        not special_case:
+            min_value = self.default_normal_range.get('min', None)
+            max_value = self.default_normal_range.get('max', None)
+
+        if age_dependent: 
+            # get normal range for age)
+            warnings.warn("Age dependent normal range not implemented yet")
+            pass
+        
+        if gender_dependent:
+            if not gender:
+                warnings.warn("Calling get_normal_range with gender_dependent=True requires gender to be set, choosing by random")
+                # set gender to either "male" or "female"
+                from random import choice
+                choices = ["male", "female"]
+                gender = choice(choices)
+
+            default_range_dict = self.default_normal_range.get(gender, {})
+            min_value = default_range_dict.get('min', None)
+            max_value = default_range_dict.get('max', None)
+
+        if special_case:
+            # get normal range for special case
+            warnings.warn("Special case normal range not implemented yet")
+
+        return min_value, max_value
+

endoreg_db/models/legacy_data/__init__.py

@@ -1,3 +1,3 @@
-from ..data_file.frame import LegacyFrame
-from .image import LegacyImage
-from ..data_file.video import LegacyVideo
+from ..data_file.frame import LegacyFrame
+from .image import LegacyImage
+from ..data_file.video import LegacyVideo

endoreg_db/models/legacy_data/image.py

@@ -1,34 +1,34 @@
-from django.db import models
-from ..label.label import Label
-from ..annotation.image_classification import ImageClassificationAnnotation
-
-class LegacyImage(models.Model):
-    # Add any other fields you need to store frame-related information
-    image = models.ImageField(upload_to="legacy_images")  # Or some other field type, depending on how you're storing the frame
-    suffix = models.CharField(max_length=255)
-    # ImageClassificationAnnotation has a foreign key to this model (related name: image_classification_annotations)
-
-    def get_classification_annotations(self):
-        """
-        Get all image classification annotations for this image.
-        """
-        return ImageClassificationAnnotation.objects.filter(legacy_image=self)
-    
-    def get_classification_annotations_by_label(self, label:Label):
-        """
-        Get all image classification annotations for this image with the given label.
-        """
-        return ImageClassificationAnnotation.objects.filter(legacy_image=self, label=label)
-    
-    def get_classification_annotations_by_value(self, value:bool):
-        """
-        Get all image classification annotations for this image with the given value.
-        """
-        return ImageClassificationAnnotation.objects.filter(legacy_image=self, value=value)
-    
-    def get_classification_annotations_by_label_and_value(self, label:Label, value:bool):
-        """
-        Get all image classification annotations for this image with the given label and value.
-        """
-        return ImageClassificationAnnotation.objects.filter(legacy_image=self, label=label, value=value)
-    
+from django.db import models
+from ..label.label import Label
+from ..annotation.image_classification import ImageClassificationAnnotation
+
+class LegacyImage(models.Model):
+    # Add any other fields you need to store frame-related information
+    image = models.ImageField(upload_to="legacy_images")  # Or some other field type, depending on how you're storing the frame
+    suffix = models.CharField(max_length=255)
+    # ImageClassificationAnnotation has a foreign key to this model (related name: image_classification_annotations)
+
+    def get_classification_annotations(self):
+        """
+        Get all image classification annotations for this image.
+        """
+        return ImageClassificationAnnotation.objects.filter(legacy_image=self)
+    
+    def get_classification_annotations_by_label(self, label:Label):
+        """
+        Get all image classification annotations for this image with the given label.
+        """
+        return ImageClassificationAnnotation.objects.filter(legacy_image=self, label=label)
+    
+    def get_classification_annotations_by_value(self, value:bool):
+        """
+        Get all image classification annotations for this image with the given value.
+        """
+        return ImageClassificationAnnotation.objects.filter(legacy_image=self, value=value)
+    
+    def get_classification_annotations_by_label_and_value(self, label:Label, value:bool):
+        """
+        Get all image classification annotations for this image with the given label and value.
+        """
+        return ImageClassificationAnnotation.objects.filter(legacy_image=self, label=label, value=value)
+    

endoreg_db/models/medication/__init__.py

@@ -0,0 +1 @@
+from .medication import *

endoreg_db/models/medication/medication.py

@@ -0,0 +1,148 @@
+from django.db import models
+
+class MedicationManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+
+class Medication(models.Model):
+    name = models.CharField(max_length=255, unique=True)
+    name_de = models.CharField(max_length=255, blank=True, null=True)
+    name_en = models.CharField(max_length=255, blank=True, null=True)
+    adapt_to_renal_function = models.BooleanField(default = False)
+    adapt_to_hepatic_function = models.BooleanField(default=False)
+    adapt_to_indication = models.BooleanField(default=False)
+    adapt_to_age = models.BooleanField(default=False)
+    adapt_to_weight = models.BooleanField(default=False)
+    adapt_to_risk = models.BooleanField(default=False)
+    default_unit = models.ForeignKey('Unit', on_delete=models.CASCADE)
+
+
+    objects = MedicationManager()
+
+    def natural_key(self):
+        return (self.name,)
+
+    def __str__(self):
+        return self.name
+    
+class MedicationScheduleManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+    
+class MedicationSchedule(models.Model):
+    name = models.CharField(max_length=255)
+    name_de = models.CharField(max_length=255, blank=True, null=True)
+    name_en = models.CharField(max_length=255, blank=True, null=True)
+    description = models.TextField(blank=True, null=True)
+    medication = models.ForeignKey("Medication", on_delete=models.CASCADE)
+    unit = models.ForeignKey("Unit", on_delete=models.CASCADE)
+    therapy_duration_d = models.FloatField(blank=True, null=True)
+    dose = models.FloatField()
+    intake_times = models.ManyToManyField(
+        "MedicationIntakeTime", 
+    )
+
+    objects = MedicationScheduleManager()
+
+    def natural_key(self):
+        return (self.name,)
+    
+    def __str__(self):
+        return self.name
+    
+    
+class MedicationIntakeTimeManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+    
+class MedicationIntakeTime(models.Model):
+    name = models.CharField(max_length=255)
+    name_de = models.CharField(max_length=255, blank=True, null=True)
+    name_en = models.CharField(max_length=255, blank=True, null=True)
+    repeats = models.CharField(max_length=20, default = "daily")
+    time = models.TimeField()
+
+    objects = MedicationIntakeTimeManager()
+
+    def natural_key(self):
+        return (self.name,)
+    
+    def __str__(self):
+        return self.name
+
+# IMPLEMENT MEDICATION INDICATION TYPE
+class MedicationIndicationTypeManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+
+class MedicationIndicationType(models.Model):
+    name = models.CharField(max_length=255, unique=True)
+    name_de = models.CharField(max_length=255, blank=True, null=True)
+    name_en = models.CharField(max_length=255, blank=True, null=True)
+
+    objects = MedicationIndicationTypeManager()
+
+    def natural_key(self):
+        return (self.name,)
+
+    def __str__(self):
+        return self.name
+    
+    @classmethod
+    def get_random_indication_by_type(cls, name) -> "MedicationIndication":
+        return cls.objects.get(name=name).medication_indications.order_by('?').first()
+    
+
+    def get_random_medication_indication(self):
+        from endoreg_db.models import MedicationIndication
+        return MedicationIndication.objects.filter(indication_type=self).order_by('?').first()
+
+
+class MedicationIndicationManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+
+class MedicationIndication(models.Model):
+    name = models.CharField(max_length=255, unique=True)
+    indication_type = models.ForeignKey(
+        "MedicationIndicationType", on_delete=models.CASCADE, related_name="medication_indications"
+    )
+    medication_schedules = models.ManyToManyField(
+        "MedicationSchedule"
+    )
+    diseases = models.ManyToManyField(
+        "Disease"
+    )
+    events = models.ManyToManyField(
+        "Event"
+    )
+    classification_choices = models.ManyToManyField(
+        "DiseaseClassificationChoice"
+    )
+    sources = models.ManyToManyField(
+        "InformationSource"
+    )
+
+    def get_indication_links(self):
+        links = {
+            "medication_schedules": self.medication_schedules,
+            "diseases": self.diseases,
+            "events": self.events,
+            "classification_choices": self.classification_choices
+        }
+
+    objects = MedicationIndicationManager()
+
+    def natural_key(self):
+        return (self.name,)
+    
+    def __str__(self):
+        return self.name
+    
+    def create_patient_medication_schedules(self, patient):
+        from endoreg_db.models import PatientMedicationSchedule
+        for medication_schedule in self.medication_schedules.all():
+            PatientMedicationSchedule.objects.create(
+                patient=patient,
+                medication_schedule=medication_schedule
+            )

endoreg_db/models/other/__init__.py

@@ -0,0 +1,5 @@
+from .material import Material
+from .resource import Resource
+from .transport_route import TransportRoute
+from .waste import Waste
+from .distribution import *

endoreg_db/models/other/distribution.py

@@ -0,0 +1,215 @@
+from django.db import models
+import numpy as np
+from scipy.stats import skewnorm
+
+class BaseValueDistribution(models.Model):
+    """
+    Abstract base class for value distributions.
+    """
+    name = models.CharField(max_length=100)
+
+    class Meta:
+        abstract = True
+
+    def generate_value(self):
+        """
+        Generate a value based on the distribution rules.
+        Must be implemented by subclasses.
+        """
+        raise NotImplementedError("Subclasses must implement this method")
+    
+    def natural_key(self):
+        return (self.name,)
+
+class NumericValueDistributionManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+
+class NumericValueDistribution(BaseValueDistribution):
+    """
+    Numeric value distribution model.
+    Supports uniform, normal, and skewed normal distributions with hard limits.
+    """
+    objects = NumericValueDistributionManager()
+    DISTRIBUTION_CHOICES = [
+        ('uniform', 'Uniform'),
+        ('normal', 'Normal'),
+        ('skewed_normal', 'Skewed Normal'),
+    ]
+
+    distribution_type = models.CharField(max_length=20, choices=DISTRIBUTION_CHOICES)
+    min_value = models.FloatField()
+    max_value = models.FloatField()
+    mean = models.FloatField(null=True, blank=True)
+    std_dev = models.FloatField(null=True, blank=True)
+    skewness = models.FloatField(null=True, blank=True)
+
+    def generate_value(self):
+        if self.distribution_type == 'uniform':
+            return np.random.uniform(self.min_value, self.max_value)
+        elif self.distribution_type == 'normal':
+            value = np.random.normal(self.mean, self.std_dev)
+            return np.clip(value, self.min_value, self.max_value)
+        elif self.distribution_type == 'skewed_normal':
+            value = skewnorm.rvs(a=self.skewness, loc=self.mean, scale=self.std_dev)
+            return np.clip(value, self.min_value, self.max_value)
+        else:
+            raise ValueError("Unsupported distribution type")
+        
+    
+class SingleCategoricalValueDistributionManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+
+class SingleCategoricalValueDistribution(BaseValueDistribution):
+    """
+    Single categorical value distribution model.
+    Assigns a single value based on specified probabilities.
+    """
+    objects = SingleCategoricalValueDistributionManager()
+    categories = models.JSONField()  # { "category": "probability", ... }
+
+    def generate_value(self):
+        categories, probabilities = zip(*self.categories.items())
+        return np.random.choice(categories, p=probabilities)
+    
+
+class MultipleCategoricalValueDistributionManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+
+class MultipleCategoricalValueDistribution(BaseValueDistribution):
+    """
+    Multiple categorical value distribution model.
+    Assigns a specific number or varying number of values based on probabilities.
+    """
+    objects = MultipleCategoricalValueDistributionManager()
+    categories = models.JSONField()  # { "category": "probability", ... }
+    min_count = models.IntegerField()
+    max_count = models.IntegerField()
+    count_distribution_type = models.CharField(max_length=20, choices=[('uniform', 'Uniform'), ('normal', 'Normal')])
+    count_mean = models.FloatField(null=True, blank=True)
+    count_std_dev = models.FloatField(null=True, blank=True)
+
+    def generate_value(self):
+        if self.count_distribution_type == 'uniform':
+            count = np.random.randint(self.min_count, self.max_count + 1)
+        elif self.count_distribution_type == 'normal':
+            count = int(np.random.normal(self.count_mean, self.count_std_dev))
+            count = np.clip(count, self.min_count, self.max_count)
+        else:
+            raise ValueError("Unsupported count distribution type")
+
+        categories, probabilities = zip(*self.categories.items())
+        return list(np.random.choice(categories, size=count, p=probabilities))
+
+
+class DateValueDistributionManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+
+from datetime import date, timedelta
+class DateValueDistribution(BaseValueDistribution):
+    """
+    Assign date values based on specified distribution.
+    Expects distribution_type (uniform, normal) and mode (date, timedelta) and based on this either
+    date_min, date_max, date_mean, date_std_dev or
+    timedelta_days_min, timedelta_days_max, timedelta_days_mean, timedelta_days_std_dev
+    """
+    objects = DateValueDistributionManager()
+    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)
+    DISTRIBUTION_CHOICES = [
+        ('uniform', 'Uniform'),
+        ('normal', 'Normal'),
+    ]
+    MODE_CHOICES = [
+        ('date', 'Date'),
+        ('timedelta', 'Timedelta'),
+    ]
+
+    distribution_type = models.CharField(max_length=20, choices=DISTRIBUTION_CHOICES)
+    mode = models.CharField(max_length=20, choices=MODE_CHOICES)
+
+    # Date-related fields
+    date_min = models.DateField(blank=True, null=True)
+    date_max = models.DateField(blank=True, null=True)
+    date_mean = models.DateField(blank=True, null=True)
+    date_std_dev = models.IntegerField(blank=True, null=True)  # Standard deviation in days
+
+    # Timedelta-related fields
+    timedelta_days_min = models.IntegerField(blank=True, null=True)
+    timedelta_days_max = models.IntegerField(blank=True, null=True)
+    timedelta_days_mean = models.IntegerField(blank=True, null=True)
+    timedelta_days_std_dev = models.IntegerField(blank=True, null=True)
+
+    def generate_value(self):
+        if self.mode == 'date':
+            return self._generate_date_value()
+        elif self.mode == 'timedelta':
+            return self._generate_timedelta_value()
+        else:
+            raise ValueError("Unsupported mode")
+
+    def _generate_date_value(self):
+        #UNTESTED
+        if self.distribution_type == 'uniform':
+            start_date = self.date_min.toordinal()
+            end_date = self.date_max.toordinal()
+            random_ordinal = np.random.randint(start_date, end_date)
+            return date.fromordinal(random_ordinal)
+        elif self.distribution_type == 'normal':
+            mean_ordinal = self.date_mean.toordinal()
+            std_dev_days = self.date_std_dev
+            random_ordinal = int(np.random.normal(mean_ordinal, std_dev_days))
+            random_ordinal = np.clip(random_ordinal, self.date_min.toordinal(), self.date_max.toordinal())
+            return date.fromordinal(random_ordinal)
+        else:
+            raise ValueError("Unsupported distribution type")
+
+    def _generate_timedelta_value(self):
+        if self.distribution_type == 'uniform':
+            random_days = np.random.randint(self.timedelta_days_min, self.timedelta_days_max + 1)
+            
+            
+        elif self.distribution_type == 'normal':
+            random_days = int(np.random.normal(self.timedelta_days_mean, self.timedelta_days_std_dev))
+            random_days = np.clip(random_days, self.timedelta_days_min, self.timedelta_days_max)
+            
+        else:
+            raise ValueError("Unsupported distribution type")
+        
+        current_date = date.today()
+        generated_date = current_date - timedelta(days=random_days)
+        print(generated_date)
+        return(generated_date)
+        
+# Example Usage
+# Numeric distribution for age
+# age_distribution = NumericValueDistribution.objects.create(
+#     name='Age Distribution',
+#     distribution_type='normal',
+#     min_value=0,
+#     max_value=100,
+#     mean=50,
+#     std_dev=15
+# )
+
+# # Single categorical distribution for gender
+# gender_distribution = SingleCategoricalValueDistribution.objects.create(
+#     name='Gender Distribution',
+#     categories={'male': 0.5, 'female': 0.5}
+# )
+
+# # Multiple categorical distribution for symptoms
+# symptoms_distribution = MultipleCategoricalValueDistribution.objects.create(
+#     name='Symptoms Distribution',
+#     categories={'fever': 0.3, 'cough': 0.4, 'fatigue': 0.2, 'nausea': 0.1},
+#     min_count=1,
+#     max_count=3,
+#     count_distribution_type='normal',
+#     count_mean=2,
+#     count_std_dev=0.5
+# )

endoreg_db/models/other/material.py

@@ -0,0 +1,16 @@
+from django.db import models
+
+class MaterialManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+
+class Material(models.Model):
+    objects = MaterialManager()
+
+    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,)

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
+