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

endoreg_db/models/other/distribution/numeric_value_distribution.py

@@ -0,0 +1,97 @@
+'''Model for numeric value distribution'''
+
+from django.db import models
+import numpy as np
+from .base_value_distribution import BaseValueDistribution
+from scipy.stats import skewnorm
+
+
+class NumericValueDistributionManager(models.Manager):
+    '''Object manager for NumericValueDistribution'''
+    def get_by_natural_key(self, name):
+        '''Retrieve a NumericValueDistribution by its natural key.'''
+        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_descriptor = models.CharField(
+        max_length=20
+    )
+
+    max_descriptor = models.CharField(
+        max_length=20
+    )
+
+    def generate_value(self, lab_value, patient):
+        '''Generate a value based on the distribution rules.'''
+        #FIXME
+        from endoreg_db.models import LabValue, Patient
+        assert isinstance(patient, Patient)
+        assert isinstance(lab_value, LabValue)
+        default_normal_range_dict = lab_value.get_normal_range(patient.age(), patient.gender)
+        assert isinstance(default_normal_range_dict, dict)
+        if self.distribution_type == 'uniform':
+            assert self.min_descriptor and self.max_descriptor
+            assert "min" in default_normal_range_dict and "max" in default_normal_range_dict
+            value = self._generate_value_uniform(default_normal_range_dict)
+            
+            return 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")
+
+    def parse_value_descriptor(self, value_descriptor:str):
+        '''Parse the value descriptor string into a dict with a lambda function.'''
+        # strings of shape f"{value_key}_{operator}_{value}"
+        # extract value_key, operator, value
+        value_key, operator, value = value_descriptor.split("_")
+        value = float(value)
+
+        operator_functions = {
+            "+": lambda x: x + value,
+            "-": lambda x: x - value,
+            "x": lambda x: x * value,
+            "/": lambda x: x / value,
+        }
+
+        return {value_key: operator_functions[operator]}
+
+        # create dict with {value_key: lambda x: x operator value}
+
+    def _generate_value_uniform(self, default_normal_range_dict:dict):
+        value_function_dict = self.parse_value_descriptor(
+            self.min_descriptor
+        )
+
+        _ = self.parse_value_descriptor(
+            self.max_descriptor
+        )
+
+        value_function_dict.update(_)
+
+        result_dict = {
+            key: value_function(default_normal_range_dict[key]) 
+            for key, value_function in value_function_dict.items()
+        }
+
+        # generate value
+        return np.random.uniform(result_dict["min"], result_dict["max"])
+
+    

endoreg_db/models/other/distribution/single_categorical_value_distribution.py

@@ -0,0 +1,22 @@
+from django.db import models
+import numpy as np
+from .base_value_distribution import BaseValueDistribution
+
+
+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)
+    
+

endoreg_db/models/other/distribution.py

@@ -1,215 +1,5 @@
-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

@@ -14,3 +14,7 @@ class Material(models.Model):
 
     def natural_key(self):
         return (self.name,)
+    
+    def __str__(self):
+        result = f"{self.name} - EmissionFactor: {self.emission_factor}"
+        return result

endoreg_db/models/other/transport_route.py

@@ -18,4 +18,5 @@ class TransportRoute(models.Model):
         return (self.name,)
     
     def __str__(self):
-        return self.name
+        result = f"{self.name} ({self.distance} {self.unit}) - {self.emission_factor}"
+        return result

endoreg_db/models/patient/__init__.py

@@ -0,0 +1,24 @@
+from .patient_examination import PatientExamination
+from .patient_finding import (
+    PatientFinding
+)
+from .patient_finding_location import (
+    PatientFindingLocation
+)
+from .patient_finding_morphology import (
+    PatientFindingMorphology
+)
+
+from .patient_finding_intervention import (
+    PatientFindingIntervention
+)
+
+# TODO Migrate to persons/patient
+
+__all__ = [
+    "PatientExamination",
+    "PatientFinding",
+    "PatientFindingLocation",
+    "PatientFindingMorphology",
+    "PatientFindingIntervention"
+]

endoreg_db/models/patient/patient_examination.py

@@ -0,0 +1,182 @@
+from django.db import models
+from typing import List
+
+# Serializer located in serializers/examination.py
+from typing import Optional
+from datetime import datetime
+
+
+class PatientExamination(models.Model):
+    patient = models.ForeignKey(
+        "Patient", on_delete=models.CASCADE, related_name="patient_examinations"
+    )
+    examination = models.ForeignKey(
+        "Examination", on_delete=models.CASCADE, null=True, blank=True
+    )
+    video = models.OneToOneField(
+        "Video",
+        on_delete=models.CASCADE,
+        null=True,
+        blank=True,
+        related_name="patient_examination",
+    )
+    date_start = models.DateField(null=True, blank=True)
+    date_end = models.DateField(null=True, blank=True)
+    hash = models.CharField(max_length=255, unique=True)
+
+    # report_files
+    class Meta:
+        verbose_name = "Patient Examination"
+        verbose_name_plural = "Patient Examinations"
+        ordering = ["patient", "examination", "date_start"]
+
+    @classmethod
+    def get_or_create_pseudo_patient_examination_by_hash(
+        cls,
+        patient_hash: str,
+        examination_hash: str,
+        examination_name: Optional[str] = None,
+    ):
+        from endoreg_db.models import Patient, Examination
+
+        created = False
+
+        if PatientExamination.objects.filter(
+            patient__patient_hash=patient_hash, hash=examination_hash
+        ).exists():
+            return PatientExamination.objects.get(
+                patient__patient_hash=patient_hash, hash=examination_hash
+            ), created
+
+        patient, created = Patient.get_or_create_pseudo_patient_by_hash(patient_hash)
+        if examination_name is not None:
+            examination = Examination.objects.get(name=examination_name)
+        else:
+            examination = None
+
+        patient_examination = cls.objects.create(
+            patient=patient, examination=examination, hash=examination_hash
+        )
+
+        patient_examination.save()
+
+        created = True
+        return patient_examination, created
+
+    def __str__(self):
+        return f"{self.patient} - {self.examination} - {self.date_start}"
+
+    # override save method to make sure that the hash is always set,
+    # if none is existing generate an unique string
+
+    def generate_default_hash(self):
+        # create random hash
+        import random
+        import string
+
+        _hash = "DEFAULT_HASH_" + "".join(
+            random.choices(string.ascii_uppercase + string.digits, k=10)
+        )
+
+        return _hash
+
+    def save(self, *args, **kwargs):
+        if not self.hash:
+            self.hash = self.generate_default_hash()
+        super().save(*args, **kwargs)
+
+    def get_patient_age_at_examination(self) -> int:
+        """
+        Returns the patient's age at the time of the examination.
+        """
+        from endoreg_db.models import Patient
+        from datetime import datetime
+
+        patient: Patient = self.patient
+        dob = patient.get_dob()
+        date_start = self.date_start
+        return (date_start - dob).days // 365
+
+    def get_available_findings(self):
+        """
+        Returns all findings that are associated with the examination of this patient examination.
+        """
+        from endoreg_db.models import Finding, Examination
+
+        examination: Examination = self.examination
+        findings: List[Finding] = [_ for _ in examination.get_available_findings()]
+        return findings
+
+    def get_findings(self):
+        """
+        Returns all findings that are associated with this patient examination.
+        """
+        from endoreg_db.models import PatientFinding
+
+        patient_findings: List[PatientFinding] = [
+            _ for _ in self.patient_findings.all()
+        ]
+        return patient_findings
+
+    def get_indications(self):
+        """
+        Returns all indications that are associated with this patient examination.
+        """
+        from endoreg_db.models import PatientExaminationIndication
+
+        indications: List[PatientExaminationIndication] = [
+            _ for _ in self.indications.all()
+        ]
+        return indications
+
+    def get_indication_choices(self):
+        """
+        Returns all indication choices that are associated with this patient examination.
+        """
+        from endoreg_db.models import ExaminationIndicationClassificationChoice
+
+        choices: List[ExaminationIndicationClassificationChoice] = [
+            _.indication_choice for _ in self.get_indications()
+        ]
+        return choices
+
+    def create_finding(self, finding):
+        """
+        Adds a finding to this patient examination.
+        """
+        from endoreg_db.models import Finding, Examination, PatientFinding
+
+        examination: Examination = self.examination
+        assert examination
+
+        finding: Finding
+
+        patient_finding = PatientFinding.objects.create(
+            patient_examination=self, finding=finding
+        )
+
+        patient_finding.save()
+
+        return patient_finding
+
+    def find_matching_video_from_patient(self):
+        """
+        Finds a video for this patient examination based on the patient's videos.
+        For this, the videos date must be the same as the report file's date.
+        #TODO add more criteria for matching: Examination type
+        """
+        videos = self.patient.video_set.filter(
+            date=self.report_file.date, patient_examination__isnull=True
+        )
+        if videos:
+            if len(videos) > 1:
+                print(
+                    f"Warning: Found more than one video for patient {self.patient} on date {self.report_file.date}. Choosing the first one."
+                )
+            return videos[0]
+        else:
+            videos = self.patient.video_set.filter(patient_examination__isnull=True)
+            if len(videos) == 1:
+                return videos[0]
+
+        return None